feat: rebuild as N1/N2 processor configurator

- N1 vs N2 specs comparison table
- Hardware constraint validation (cores, neurons, synapses)
- Local LIF simulator (no API key needed)
- Spike raster visualisation
- Cloud API tab for full-scale compute

README.md

@@ -1,5 +1,5 @@
 ---
-title: Catalyst Cloud - Neuromorphic Simulator
+title: Catalyst Neuromorphic — Processor Configurator
 emoji: '🧠'
 colorFrom: blue
 colorTo: purple
@@ -9,13 +9,27 @@ python_version: "3.12"
 app_file: app.py
 pinned: false
 license: mit
-short_description: Run hardware-accurate spiking neural network simulations
+short_description: N1/N2 neuromorphic processor configurator
 ---
 
-# Catalyst Cloud - Neuromorphic Simulator
+# Catalyst Neuromorphic — Processor Configurator
 
-Run hardware-accurate spiking neural network simulations in the cloud. Full Loihi 2 parity. No hardware required.
+Explore the **N1** and **N2** spiking neuromorphic processors. Compare specs, configure networks with hardware constraint validation, and run local LIF simulations with spike raster visualisation.
 
-Sign up for a free API key, configure your network, and visualize spike rasters - all from this demo.
+**No API key required** — simulations run locally in the browser.
 
-[Website](https://catalyst-neuromorphic.com/cloud) | [API Docs](https://catalyst-neuromorphic.com/cloud/docs) | [pip install catalyst-cloud](https://pypi.org/project/catalyst-cloud/)
+For full-scale hardware-accurate simulations, use the [Catalyst Cloud API](https://catalyst-neuromorphic.com/cloud).
+
+## Features
+
+- **Processor comparison** — N1 (Loihi 1 parity) vs N2 (Loihi 2 parity) side-by-side
+- **Hardware constraint validation** — check if your network fits on the target processor
+- **Live LIF simulation** — configure neurons, connections, and topology
+- **Spike raster visualisation** — see firing patterns across populations
+
+## Links
+
+- [Website](https://catalyst-neuromorphic.com)
+- [Cloud API](https://catalyst-neuromorphic.com/cloud)
+- [Python SDK](https://pypi.org/project/catalyst-cloud/)
+- [N1 Paper (Zenodo)](https://zenodo.org/records/18727094)

app.py

@@ -1,224 +1,507 @@
-"""Catalyst Cloud — Interactive Neuromorphic Simulator Demo.
+"""Catalyst Neuromorphic — Interactive Processor Configurator & Simulator.
 
-Runs spiking neural network simulations via the Catalyst Cloud API
-and displays spike raster plots.
+Explore the N1 and N2 neuromorphic processors, configure spiking neural
+networks with hardware-accurate constraints, and run local simulations
+with live spike raster visualisation.
 """
 
 import gradio as gr
-import requests
 import numpy as np
 
-API_URL = "https://api.catalyst-neuromorphic.com"
+# ── Processor specs ──────────────────────────────────────────────────────────
+
+PROCESSORS = {
+    "N1": {
+        "cores": 128,
+        "neurons_per_core": 1024,
+        "synapses_per_core": 131072,
+        "total_neurons": 131072,
+        "dendrites": 4,
+        "graded_spike_bits": 8,
+        "learning_opcodes": 14,
+        "max_axon_delay": 63,
+        "parity": "Intel Loihi 1",
+        "neuron_models": ["LIF"],
+        "features": [
+            "Dendritic compartments (4 per neuron)",
+            "Graded spikes (8-bit payload)",
+            "On-chip learning (14-opcode ISA, STDP)",
+            "Axonal delays (up to 63 timesteps)",
+            "Programmable synaptic plasticity",
+        ],
+    },
+    "N2": {
+        "cores": 128,
+        "neurons_per_core": 1024,
+        "synapses_per_core": 131072,
+        "total_neurons": 131072,
+        "dendrites": 4,
+        "graded_spike_bits": 8,
+        "learning_opcodes": 18,
+        "max_axon_delay": 63,
+        "parity": "Intel Loihi 2",
+        "neuron_models": ["LIF", "CUBA", "ALIF", "Izhikevich", "Custom"],
+        "features": [
+            "Programmable neuron models (microcode engine)",
+            "CUBA, LIF, ALIF, Izhikevich built-in",
+            "Custom neuron models via microcode",
+            "Graded spikes (8-bit payload)",
+            "On-chip learning (18-opcode ISA)",
+            "Dendritic compartments (4 per neuron)",
+            "Axonal delays (up to 63 timesteps)",
+            "Multi-chip scalability",
+            "Three-factor learning rules",
+        ],
+    },
+}
+
+
+# ── Local LIF simulator ─────────────────────────────────────────────────────
+
+def simulate_lif(populations, connections, timesteps, dt=1.0):
+    """Run a simple LIF simulation. Returns spike times per population."""
+    # Build neuron arrays
+    pop_offsets = {}
+    total = 0
+    for p in populations:
+        pop_offsets[p["label"]] = total
+        total += p["size"]
+
+    voltage = np.zeros(total)
+    threshold = np.array([1000.0] * total)
+    leak = np.array([50.0] * total)
+    refrac = np.zeros(total, dtype=int)
+
+    # Apply per-population params
+    for p in populations:
+        off = pop_offsets[p["label"]]
+        sz = p["size"]
+        threshold[off : off + sz] = p.get("threshold", 1000)
+        leak[off : off + sz] = p.get("leak", 50)
+
+    # Build weight matrix
+    W = np.zeros((total, total))
+    for c in connections:
+        src_off = pop_offsets[c["source"]]
+        src_sz = next(p["size"] for p in populations if p["label"] == c["source"])
+        tgt_off = pop_offsets[c["target"]]
+        tgt_sz = next(p["size"] for p in populations if p["label"] == c["target"])
+
+        topo = c.get("topology", "random_sparse")
+        w = c.get("weight", 500)
+        prob = c.get("probability", 0.3)
+
+        if topo == "all_to_all":
+            W[tgt_off : tgt_off + tgt_sz, src_off : src_off + src_sz] = w
+        elif topo == "one_to_one":
+            n = min(src_sz, tgt_sz)
+            for i in range(n):
+                W[tgt_off + i, src_off + i] = w
+        else:  # random_sparse
+            mask = np.random.random((tgt_sz, src_sz)) < prob
+            W[tgt_off : tgt_off + tgt_sz, src_off : src_off + src_sz] = mask * w
+
+    # Stimulus: constant current to first population
+    stim_pop = populations[0]
+    stim_off = pop_offsets[stim_pop["label"]]
+    stim_sz = stim_pop["size"]
+    stim_current = np.zeros(total)
+    stim_current[stim_off : stim_off + stim_sz] = populations[0].get("input_current", 800)
+
+    # Run
+    spike_times = {p["label"]: {} for p in populations}
+
+    for t in range(timesteps):
+        # Refractory
+        active = refrac <= 0
+
+        # Leak
+        voltage = voltage * (1.0 - leak / 4096.0)
+
+        # Synaptic input from previous spikes
+        spikes_vec = np.zeros(total)
+        for p in populations:
+            off = pop_offsets[p["label"]]
+            sz = p["size"]
+            for nid_str, times in spike_times[p["label"]].items():
+                nid = int(nid_str)
+                if times and times[-1] == t - 1:
+                    spikes_vec[off + nid] = 1.0
+
+        synaptic = W @ spikes_vec
+
+        # Update voltage
+        voltage += (stim_current + synaptic) * active
+
+        # Noise (small)
+        voltage += np.random.randn(total) * 20 * active
+
+        # Spike detection
+        fired = (voltage >= threshold) & active
+        indices = np.where(fired)[0]
+
+        for idx in indices:
+            # Find which population
+            for p in populations:
+                off = pop_offsets[p["label"]]
+                sz = p["size"]
+                if off <= idx < off + sz:
+                    nid = idx - off
+                    key = str(nid)
+                    if key not in spike_times[p["label"]]:
+                        spike_times[p["label"]][key] = []
+                    spike_times[p["label"]][key].append(t)
+                    break
+
+        # Reset
+        voltage[fired] = 0.0
+        refrac[fired] = 3  # refractory period
+        refrac -= 1
+        refrac = np.maximum(refrac, 0)
+
+    return spike_times, pop_offsets
+
+
+def make_raster(populations, spike_times, timesteps):
+    """Create a dark-themed spike raster plot."""
+    import matplotlib
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+
+    fig, ax = plt.subplots(figsize=(12, 5), dpi=100)
+    fig.patch.set_facecolor("#0d1117")
+    ax.set_facecolor("#0d1117")
+
+    colors = ["#4A9EFF", "#FF6B6B", "#50C878", "#FFD93D", "#C084FC"]
+    neuron_offset = 0
+
+    total_spikes = 0
+    for i, pop in enumerate(populations):
+        color = colors[i % len(colors)]
+        pop_spikes = spike_times.get(pop["label"], {})
+
+        for nid_str, times in pop_spikes.items():
+            nid = int(nid_str)
+            y = neuron_offset + nid
+            ax.scatter(times, [y] * len(times), s=1.5, c=color, marker="|", linewidths=0.6)
+            total_spikes += len(times)
+
+        mid = neuron_offset + pop["size"] // 2
+        ax.annotate(
+            f'{pop["label"]}\n({pop["size"]})',
+            xy=(-0.01, mid),
+            xycoords=("axes fraction", "data"),
+            fontsize=8,
+            color=color,
+            ha="right",
+            va="center",
+        )
+        neuron_offset += pop["size"]
+
+    ax.set_xlabel("Timestep", color="#8b949e", fontsize=10)
+    ax.set_title("Spike Raster", color="white", fontsize=12, fontweight="bold", pad=10)
+    ax.tick_params(colors="#8b949e", labelsize=8)
+    ax.spines["bottom"].set_color("#30363d")
+    ax.spines["left"].set_color("#30363d")
+    ax.spines["top"].set_visible(False)
+    ax.spines["right"].set_visible(False)
+    ax.set_xlim(-1, timesteps + 1)
+    ax.set_ylim(-1, neuron_offset)
+    ax.set_yticks([])
+
+    plt.tight_layout()
+    return fig, total_spikes
+
+
+# ── Hardware constraint validation ───────────────────────────────────────────
+
+def validate_hardware(processor, populations, connections):
+    """Check if the network fits on the selected processor."""
+    spec = PROCESSORS[processor]
+    total_neurons = sum(p["size"] for p in populations)
+    max_neurons = spec["total_neurons"]
+
+    cores_needed = max(1, -(-total_neurons // spec["neurons_per_core"]))  # ceil div
+    cores_available = spec["cores"]
+
+    total_synapses = 0
+    for c in connections:
+        src_sz = next(p["size"] for p in populations if p["label"] == c["source"])
+        tgt_sz = next(p["size"] for p in populations if p["label"] == c["target"])
+        topo = c.get("topology", "random_sparse")
+        prob = c.get("probability", 0.3)
+        if topo == "all_to_all":
+            total_synapses += src_sz * tgt_sz
+        elif topo == "one_to_one":
+            total_synapses += min(src_sz, tgt_sz)
+        else:
+            total_synapses += int(src_sz * tgt_sz * prob)
 
+    fits = cores_needed <= cores_available
+    utilisation = (cores_needed / cores_available) * 100
+
+    report = f"### Hardware Mapping: {processor}\n\n"
+    report += f"| Resource | Used | Available | Status |\n"
+    report += f"|----------|------|-----------|--------|\n"
+    report += f"| Neurons | {total_neurons:,} | {max_neurons:,} | {'OK' if total_neurons <= max_neurons else 'OVER'} |\n"
+    report += f"| Cores | {cores_needed} | {cores_available} | {'OK' if fits else 'OVER'} |\n"
+    report += f"| Synapses | {total_synapses:,} | {spec['synapses_per_core'] * cores_available:,} | est. |\n"
+    report += f"| Utilisation | {utilisation:.1f}% | | |\n\n"
+
+    if fits:
+        report += f"**Network fits on {processor}.** Using {cores_needed}/{cores_available} cores ({utilisation:.1f}%)."
+    else:
+        report += f"**Network does NOT fit on {processor}.** Needs {cores_needed} cores but only {cores_available} available. Reduce neuron count."
+
+    return report, fits
 
-def signup(email: str) -> str:
-    """Sign up for a free API key."""
-    if not email or "@" not in email:
-        return "Please enter a valid email address."
-    try:
-        resp = requests.post(f"{API_URL}/v1/signup", json={"email": email, "tier": "free"}, timeout=15)
-        if resp.status_code == 200:
-            data = resp.json()
-            return f"Your API key: {data['api_key']}\n\nSave this — it's shown only once.\nFree tier: {data['limits']['max_neurons']} neurons, {data['limits']['max_timesteps']} timesteps, {data['limits']['max_jobs_per_day']} jobs/day."
-        else:
-            return f"Error: {resp.json().get('detail', resp.text)}"
-    except Exception as e:
-        return f"Connection error: {e}"
 
+# ── Main interface ───────────────────────────────────────────────────────────
 
-def run_simulation(api_key: str, input_size: int, hidden_size: int, output_size: int,
-                   topology: str, weight: int, sparsity: float, timesteps: int,
-                   input_current: int):
-    """Run a simulation and return results + raster plot."""
-    if not api_key or not api_key.startswith("cn_live_"):
-        return "Enter a valid API key (starts with cn_live_)", None
+def run_demo(processor, num_cores, neurons_per_core, neuron_model,
+             hidden_size, output_size, topology, weight, probability,
+             timesteps, input_current):
+    """Configure, validate, and simulate."""
 
-    headers = {"X-API-Key": api_key, "Content-Type": "application/json"}
+    input_size = num_cores * neurons_per_core
+    if input_size > 2048:
+        input_size = 2048  # cap for demo performance
 
-    # Build populations
-    populations = [{"label": "input", "size": input_size, "params": {"threshold": 1000}}]
+    populations = [
+        {"label": "input", "size": min(input_size, 512), "threshold": 1000,
+         "leak": 50, "input_current": input_current},
+    ]
     connections = []
 
     if hidden_size > 0:
-        populations.append({"label": "hidden", "size": hidden_size, "params": {"threshold": 1000}})
+        populations.append({"label": "hidden", "size": hidden_size,
+                            "threshold": 1000, "leak": 50})
         connections.append({
             "source": "input", "target": "hidden",
-            "topology": topology, "weight": weight, "p": sparsity,
+            "topology": topology, "weight": weight, "probability": probability,
         })
-        if output_size > 0:
-            populations.append({"label": "output", "size": output_size, "params": {"threshold": 1000}})
-            connections.append({
-                "source": "hidden", "target": "output",
-                "topology": topology, "weight": weight, "p": sparsity,
-            })
-    elif output_size > 0:
-        populations.append({"label": "output", "size": output_size, "params": {"threshold": 1000}})
+
+    if output_size > 0:
+        src = "hidden" if hidden_size > 0 else "input"
+        populations.append({"label": "output", "size": output_size,
+                            "threshold": 1000, "leak": 50})
         connections.append({
-            "source": "input", "target": "output",
-            "topology": topology, "weight": weight, "p": sparsity,
+            "source": src, "target": "output",
+            "topology": topology, "weight": weight, "probability": probability,
         })
 
-    total = sum(p["size"] for p in populations)
-    if total > 1024:
-        return f"Total neurons ({total}) exceeds free tier limit (1024). Reduce sizes.", None
-
-    try:
-        # Create network
-        resp = requests.post(f"{API_URL}/v1/networks", headers=headers,
-                             json={"populations": populations, "connections": connections}, timeout=15)
-        if resp.status_code != 200:
-            return f"Network error: {resp.json().get('detail', resp.text)}", None
-
-        network_id = resp.json()["network_id"]
-
-        # Submit job
-        resp = requests.post(f"{API_URL}/v1/jobs", headers=headers, json={
-            "network_id": network_id,
-            "timesteps": timesteps,
-            "stimuli": [{"population": "input", "current": input_current}],
-        }, timeout=15)
-        if resp.status_code != 200:
-            return f"Job error: {resp.json().get('detail', resp.text)}", None
-
-        job_id = resp.json()["job_id"]
-
-        # Poll for completion
-        import time
-        for _ in range(60):
-            time.sleep(0.5)
-            resp = requests.get(f"{API_URL}/v1/jobs/{job_id}", headers=headers, timeout=15)
-            job = resp.json()
-            if job["status"] == "completed":
-                break
-            if job["status"] == "failed":
-                return f"Simulation failed: {job.get('error_message', 'Unknown error')}", None
-        else:
-            return "Timeout waiting for simulation to complete.", None
-
-        result = job["result"]
-
-        # Get spike trains
-        resp = requests.get(f"{API_URL}/v1/jobs/{job_id}/spikes", headers=headers, timeout=15)
-        spikes = resp.json()["spike_trains"]
-
-        # Build raster plot
-        import matplotlib
-        matplotlib.use("Agg")
-        import matplotlib.pyplot as plt
-
-        fig, ax = plt.subplots(figsize=(10, 5))
-        fig.patch.set_facecolor("#0a0a0a")
-        ax.set_facecolor("#0a0a0a")
-
-        colors = {"input": "#4A9EFF", "hidden": "#FF6B6B", "output": "#50C878"}
-        neuron_offset = 0
-        yticks = []
-        yticklabels = []
-
-        for pop_label in [p["label"] for p in populations]:
-            pop_size = next(p["size"] for p in populations if p["label"] == pop_label)
-            pop_spikes = spikes.get(pop_label, {})
-            color = colors.get(pop_label, "#FFFFFF")
-
-            for neuron_str, times in pop_spikes.items():
-                neuron_idx = int(neuron_str)
-                y = neuron_offset + neuron_idx
-                ax.scatter(times, [y] * len(times), s=1, c=color, marker="|", linewidths=0.5)
-
-            mid = neuron_offset + pop_size // 2
-            yticks.append(mid)
-            yticklabels.append(f"{pop_label}\n({pop_size})")
-            neuron_offset += pop_size
-
-        ax.set_xlabel("Timestep", color="white", fontsize=11)
-        ax.set_ylabel("Neuron", color="white", fontsize=11)
-        ax.set_title("Spike Raster Plot", color="white", fontsize=13, fontweight="bold")
-        ax.set_yticks(yticks)
-        ax.set_yticklabels(yticklabels, fontsize=9)
-        ax.tick_params(colors="white")
-        ax.spines["bottom"].set_color("#333")
-        ax.spines["left"].set_color("#333")
-        ax.spines["top"].set_visible(False)
-        ax.spines["right"].set_visible(False)
-        ax.set_xlim(-1, timesteps + 1)
-        ax.set_ylim(-1, neuron_offset)
-
-        plt.tight_layout()
-
-        summary = (
-            f"Total spikes: {result['total_spikes']}\n"
-            f"Timesteps: {result['timesteps']}\n"
-            f"Compute time: {job['compute_seconds']:.4f}s\n\n"
-            f"Firing rates:\n" +
-            "\n".join(f"  {k}: {v:.4f}" for k, v in result["firing_rates"].items())
-        )
-
-        return summary, fig
+    # Validate
+    hw_report, fits = validate_hardware(processor, populations, connections)
 
-    except Exception as e:
-        return f"Error: {e}", None
-
-
-# -- Gradio UI --
+    # Cap simulation size for responsiveness
+    total = sum(p["size"] for p in populations)
+    if total > 2000:
+        return hw_report + "\n\n*Demo capped at 2,000 neurons for browser performance. Full scale available via Cloud API.*", None
+
+    # Simulate
+    spike_times, _ = simulate_lif(populations, connections, timesteps)
+    fig, total_spikes = make_raster(populations, spike_times, timesteps)
+
+    # Stats
+    stats = f"\n\n---\n### Simulation Results\n"
+    stats += f"- **Total spikes**: {total_spikes:,}\n"
+    stats += f"- **Timesteps**: {timesteps}\n"
+    stats += f"- **Neuron model**: {neuron_model}\n"
+
+    for p in populations:
+        pop_spikes = sum(len(t) for t in spike_times[p["label"]].values())
+        rate = pop_spikes / (p["size"] * timesteps) if p["size"] * timesteps > 0 else 0
+        stats += f"- **{p['label']}**: {pop_spikes:,} spikes ({rate:.3f} spikes/neuron/step)\n"
+
+    return hw_report + stats, fig
+
+
+def get_neuron_models(processor):
+    """Return available neuron models for selected processor."""
+    return gr.update(choices=PROCESSORS[processor]["neuron_models"],
+                     value=PROCESSORS[processor]["neuron_models"][0])
+
+
+def get_processor_info(processor):
+    """Return markdown specs for selected processor."""
+    spec = PROCESSORS[processor]
+    md = f"## Catalyst {processor}\n\n"
+    md += f"**Parity**: {spec['parity']}\n\n"
+    md += f"| Spec | Value |\n|------|-------|\n"
+    md += f"| Cores | {spec['cores']} |\n"
+    md += f"| Neurons/core | {spec['neurons_per_core']:,} |\n"
+    md += f"| Total neurons | {spec['total_neurons']:,} |\n"
+    md += f"| Synapses/core | {spec['synapses_per_core']:,} |\n"
+    md += f"| Dendrites | {spec['dendrites']} compartments |\n"
+    md += f"| Graded spikes | {spec['graded_spike_bits']}-bit |\n"
+    md += f"| Learning opcodes | {spec['learning_opcodes']} |\n"
+    md += f"| Max axon delay | {spec['max_axon_delay']} timesteps |\n"
+    md += f"| Neuron models | {', '.join(spec['neuron_models'])} |\n\n"
+    md += "### Key Features\n\n"
+    for f in spec["features"]:
+        md += f"- {f}\n"
+    return md
+
+
+# ── Gradio app ───────────────────────────────────────────────────────────────
 
 with gr.Blocks(
-    title="Catalyst Cloud — Neuromorphic Simulator",
+    title="Catalyst Neuromorphic — Processor Configurator",
     theme=gr.themes.Base(
         primary_hue="blue",
         neutral_hue="slate",
+        font=gr.themes.GoogleFont("Inter"),
     ),
+    css="""
+    .gradio-container { max-width: 1100px !important; }
+    .dark { background: #0d1117 !important; }
+    """,
 ) as demo:
     gr.Markdown("""
-    # Catalyst Cloud — Neuromorphic Simulator
-    Run hardware-accurate spiking neural network simulations in the cloud.
-    Full Loihi 2 parity. No hardware required.
+# Catalyst Neuromorphic — Processor Configurator
+
+Explore the **N1** and **N2** spiking neuromorphic processors.
+Configure networks, validate hardware constraints, and run simulations — all in the browser.
     """)
 
-    with gr.Tab("Get API Key"):
-        email_input = gr.Textbox(label="Email", placeholder="you@lab.edu")
-        signup_btn = gr.Button("Sign up (free)")
-        signup_output = gr.Textbox(label="Result", lines=4)
-        signup_btn.click(signup, inputs=[email_input], outputs=[signup_output])
+    with gr.Tab("Processors"):
+        gr.Markdown("""
+### Compare the N1 and N2 neuromorphic processors
 
-    with gr.Tab("Simulate"):
-        api_key_input = gr.Textbox(label="API Key", placeholder="cn_live_...", type="password")
+| | **N1** | **N2** |
+|---|---|---|
+| **Parity** | Intel Loihi 1 | Intel Loihi 2 |
+| **Cores** | 128 | 128 |
+| **Neurons/core** | 1,024 | 1,024 |
+| **Total neurons** | 131,072 | 131,072 |
+| **Neuron models** | LIF | LIF, CUBA, ALIF, Izhikevich, Custom |
+| **Learning** | 14-opcode ISA, STDP | 18-opcode ISA, three-factor |
+| **Dendrites** | 4 compartments | 4 compartments |
+| **Graded spikes** | 8-bit | 8-bit |
+| **Max axon delay** | 63 timesteps | 63 timesteps |
+| **Key advance** | Foundation | Programmable neuron microcode engine |
 
-        with gr.Row():
-            input_size = gr.Slider(1, 500, value=50, step=1, label="Input neurons")
-            hidden_size = gr.Slider(0, 500, value=30, step=1, label="Hidden neurons (0 = skip)")
-            output_size = gr.Slider(0, 200, value=20, step=1, label="Output neurons (0 = skip)")
+The **N1** is a complete neuromorphic processor with full Loihi 1 parity — 128 cores, on-chip learning, dendritic computation.
+
+The **N2** adds a **programmable microcode engine** for custom neuron models. Instead of hardwired LIF, you can program arbitrary neuron dynamics — CUBA, ALIF, Izhikevich, or anything you design.
 
+Both have been validated on FPGA. Both are fully open-design.
+
+**Papers**: [N1 Paper (Zenodo)](https://zenodo.org/records/18727094) | [N2 Paper](/papers/catalyst-n2.pdf)
+
+**Website**: [catalyst-neuromorphic.com](https://catalyst-neuromorphic.com)
+        """)
+
+    with gr.Tab("Configure & Simulate"):
         with gr.Row():
-            topology = gr.Dropdown(
-                ["all_to_all", "one_to_one", "random_sparse"],
-                value="random_sparse", label="Topology",
-            )
-            weight = gr.Slider(100, 2000, value=800, step=50, label="Synaptic weight")
-            sparsity = gr.Slider(0.01, 1.0, value=0.3, step=0.01, label="Connection probability")
+            with gr.Column(scale=1):
+                processor = gr.Radio(
+                    ["N1", "N2"], value="N2", label="Processor",
+                    info="Select which processor to target",
+                )
+                neuron_model = gr.Dropdown(
+                    ["LIF", "CUBA", "ALIF", "Izhikevich", "Custom"],
+                    value="LIF", label="Neuron Model",
+                    info="N2 supports programmable models",
+                )
+                num_cores = gr.Slider(1, 128, value=4, step=1,
+                                      label="Cores", info="How many cores to use")
+                neurons_per_core = gr.Slider(1, 1024, value=64, step=1,
+                                              label="Neurons per core")
+
+            with gr.Column(scale=1):
+                hidden_size = gr.Slider(0, 512, value=128, step=1,
+                                        label="Hidden neurons", info="0 = direct input→output")
+                output_size = gr.Slider(0, 256, value=64, step=1,
+                                        label="Output neurons", info="0 = no output layer")
+                topology = gr.Dropdown(
+                    ["all_to_all", "one_to_one", "random_sparse"],
+                    value="random_sparse", label="Connection Topology",
+                )
+                weight = gr.Slider(100, 3000, value=800, step=50,
+                                   label="Synaptic Weight")
+                probability = gr.Slider(0.01, 1.0, value=0.3, step=0.01,
+                                        label="Connection Probability",
+                                        info="For random_sparse topology")
 
         with gr.Row():
-            timesteps = gr.Slider(10, 1000, value=200, step=10, label="Timesteps")
-            input_current = gr.Slider(500, 10000, value=5000, step=500, label="Input current")
+            timesteps = gr.Slider(10, 500, value=200, step=10, label="Timesteps")
+            input_current = gr.Slider(100, 5000, value=800, step=100,
+                                      label="Input Current")
 
-        run_btn = gr.Button("Run simulation", variant="primary")
+        run_btn = gr.Button("Simulate", variant="primary", size="lg")
 
         with gr.Row():
-            result_text = gr.Textbox(label="Results", lines=8)
-            raster_plot = gr.Plot(label="Spike raster")
+            hw_report = gr.Markdown(label="Hardware Report")
+        raster_plot = gr.Plot(label="Spike Raster")
+
+        # Events
+        processor.change(get_neuron_models, inputs=[processor], outputs=[neuron_model])
 
         run_btn.click(
-            run_simulation,
-            inputs=[api_key_input, input_size, hidden_size, output_size,
-                    topology, weight, sparsity, timesteps, input_current],
-            outputs=[result_text, raster_plot],
+            run_demo,
+            inputs=[processor, num_cores, neurons_per_core, neuron_model,
+                    hidden_size, output_size, topology, weight, probability,
+                    timesteps, input_current],
+            outputs=[hw_report, raster_plot],
         )
 
+    with gr.Tab("Cloud API"):
+        gr.Markdown("""
+### Run at scale with the Catalyst Cloud API
+
+The simulator above runs locally in the browser for small networks.
+For **full-scale simulations** (131K+ neurons, hardware-accurate timing, on-chip learning),
+use the Catalyst Cloud API.
+
+**Install the Python SDK:**
+```bash
+pip install catalyst-cloud
+```
+
+**Quick start:**
+```python
+from catalyst_cloud import Client
+
+client = Client("cn_live_your_key_here")
+
+# Create a network
+net = client.create_network(
+    populations=[
+        {"label": "input", "size": 700},
+        {"label": "hidden", "size": 512, "params": {"threshold": 1000}},
+    ],
+    connections=[
+        {"source": "input", "target": "hidden",
+         "topology": "random_sparse", "weight": 500, "p": 0.3},
+    ],
+)
+
+# Run simulation
+result = client.simulate(
+    network_id=net["network_id"],
+    timesteps=250,
+    stimuli=[{"population": "input", "current": 5000}],
+)
+
+print(f"Total spikes: {result['total_spikes']}")
+```
+
+### Links
+
+- [Sign up for free](https://catalyst-neuromorphic.com/cloud)
+- [API Documentation](https://catalyst-neuromorphic.com/cloud/docs)
+- [Pricing](https://catalyst-neuromorphic.com/cloud/pricing)
+- [PyPI: catalyst-cloud](https://pypi.org/project/catalyst-cloud/)
+- [GitHub: catalyst-cloud-python](https://github.com/catalyst-neuromorphic/catalyst-cloud-python)
+        """)
+
     gr.Markdown("""
-    ---
-    [Website](https://catalyst-neuromorphic.com/cloud) |
-    [API Docs](https://catalyst-neuromorphic.com/cloud/docs) |
-    [Pricing](https://catalyst-neuromorphic.com/cloud/pricing) |
-    [pip install catalyst-cloud](https://pypi.org/project/catalyst-cloud/)
+---
+[Website](https://catalyst-neuromorphic.com) |
+[Research](https://catalyst-neuromorphic.com/research) |
+[Cloud API](https://catalyst-neuromorphic.com/cloud) |
+[GitHub](https://github.com/catalyst-neuromorphic)
     """)
 
 demo.launch()

monitor_space.py

@@ -0,0 +1,42 @@
+"""Monitor HF Space health for 1 hour after deployment."""
+import requests
+import time
+import datetime
+
+SPACE_URL = "https://mrwabbit-catalyst-cloud.hf.space/"
+CHECK_INTERVAL = 120  # seconds (every 2 minutes)
+TOTAL_DURATION = 3600  # 1 hour
+
+start = time.time()
+checks = 0
+failures = 0
+
+print(f"[{datetime.datetime.now():%H:%M:%S}] Starting HF Space monitoring for 1 hour...")
+print(f"URL: {SPACE_URL}")
+print(f"Check interval: {CHECK_INTERVAL}s")
+print("-" * 60)
+
+while time.time() - start < TOTAL_DURATION:
+    checks += 1
+    elapsed = int(time.time() - start)
+    try:
+        r = requests.get(SPACE_URL, timeout=30)
+        status = r.status_code
+        ok = 200 <= status < 400
+        if ok:
+            print(f"[{datetime.datetime.now():%H:%M:%S}] Check #{checks} ({elapsed//60}m): OK (HTTP {status})")
+        else:
+            failures += 1
+            print(f"[{datetime.datetime.now():%H:%M:%S}] Check #{checks} ({elapsed//60}m): FAIL (HTTP {status})")
+    except Exception as e:
+        failures += 1
+        print(f"[{datetime.datetime.now():%H:%M:%S}] Check #{checks} ({elapsed//60}m): ERROR ({e})")
+    
+    time.sleep(CHECK_INTERVAL)
+
+print("-" * 60)
+print(f"Monitoring complete. {checks} checks, {failures} failures.")
+if failures == 0:
+    print("RESULT: Space is HEALTHY - no issues detected in 1 hour.")
+else:
+    print(f"RESULT: {failures} failures detected - investigate!")

requirements.txt

@@ -1,4 +1,3 @@
-gradio==5.12.0
-requests
+gradio>=5.0,<6.0
 numpy
 matplotlib