Initiative: Zero to Silicon - Content Scaffolding & Format Adoption

[neural-loop]

Context & Objectives

Historically, coordination for the Zero to Silicon (ZTS) series has been fragmented across private Discord messages, making it difficult for the Executive Committee (EC) and volunteers to stay aligned on the project's status.

Insights & Proposed Format Shift (via @eljoserass)

Jose is currently participating in the Neuromatch Computational Neuroscience course and has highlighted several highly effective pedagogical strategies that we should adapt for Zero to Silicon:

1. Format & Infrastructure:
   • Shift away from heavy reliance on live lecturers. Instead, use pre-recorded videos (one longer conceptual introduction, followed by short, section-specific videos).
   • Prioritize Google Colabs for all tutorials (even adapting hardware/Verilog concepts to Colabs where possible) so users can immediately get hands-on.
2. Mini-Research Projects:
   • Alongside tutorials, provide dedicated project blocks where participants choose from curated datasets, are guided through relevant literature, and frame actual research questions.
3. Target Audience & Prerequisites:
   • We need to formally define the target audience. "Absolute zero" might be an understatement; we need to establish basic prerequisites so the content hits the right abstraction level.

Current Status

• Content: We previously underestimated the time required for research, writing, and review. The focus needs to shift from finding speakers to building standalone content.
• Progress: Ray has reportedly made significant progress on the foundational neuroscience topics.
• Timeline: @eljoserass will have high bandwidth to actively build and test this content during August, making it our primary window for ZTS content scaffolding before the fall.

Actionable Next Steps

• Content Audit: Follow up with Ray to review the existing neuroscience materials and assess what is ready to be ported into Colab/Markdown.
• Draft the Prerequisites: Clearly define what a participant needs to know before starting ZTS (e.g., basic Python, fundamental math).
• August Scaffolding Sprint: Schedule an August kickoff meeting to map out the first 2-3 Colab modules

--
High level planning and initiative direction can be kept here, and this can be a good place to coordinate when having 'water cooler' chats that aren't in the public channels.

[neural-loop]

By adopting Neuromatch's battle-tested infrastructure, Open Neuromorphic instantly gains:

1. Out-of-the-box CI/CD Automation: Automated stripping of solutions to generate student/ and instructor/ notebooks via nmaci.
2. Interactive Platform Badging: Automatic generation of Open in Colab, Kaggle, and NBViewer badges.
3. Ebook Publishing: Direct build pipelines using jupyter-book to render a unified, web-searchable course portal.
4. Standardized Pedagogical Format: Clear separation between concept intros, hands-on tutorial exercises, outros, and further reading.

Below is a strategic and technical guide to integrating the Zero to Silicon (Z2S) curriculum into this architecture, resolving team discussions and mapping out the implementation plan.

---

1. Resolving the "One Notebook vs. Multi-Notebook" Approach

• Jose's "One Notebook" Prototype (The Sandbox Phase): Use a single sandbox notebook (e.g., sandbox_z2s_pipeline.ipynb) as a Proof of Concept. Its sole purpose is to test the Google Colab toolchain—specifically installing verilator via apt-get, writing Verilog inline via %%file magic commands, executing C++ testbenches, and parsing VCD waveforms into Matplotlib plots.
• Blair's "Multi-Week Modular" Design (The Release Architecture): Once the Colab Verilog toolchain is verified in the sandbox, break Z2S out into dedicated NMA-style daily directories (W1D1, W1D2, etc.). Learning hardware description and spiking neuron theory in a single notebook causes cognitive overload; modularizing it into distinct days matches NMA’s proven learning retention model.

---

2. Curriculum Mapping: Z2S Tasks $\rightarrow$ NMA Days & Tutorials

NMA structures courses into Weeks, Days (W1D1), and Tutorial Notebooks (Tutorial1.ipynb, Tutorial2.ipynb). Here is how the 6 Zero to Silicon tasks map onto an NMA-style 1-Week Intensive or 2-Week Modular Course:

open-neuromorphic/course-content/
└── tutorials/
    ├── materials.yml                       # Course Master Manifest
    ├── W1D1_NeuronFoundations/             # Z2S Task 1: Anatomy & Voltage Traces
    │   ├── README.md
    │   ├── W1D1_Intro.ipynb
    │   ├── W1D1_Tutorial1.ipynb            # Biological & Qualitative LIF
    │   ├── W1D1_Outro.ipynb
    │   └── further_reading.md
    ├── W1D2_PythonLIFPrototyping/          # Z2S Task 2: Python / NumPy Reference Model
    │   ├── README.md
    │   ├── W1D2_Intro.ipynb
    │   ├── W1D2_Tutorial1.ipynb            # Coding LIFNeuron class & f-I curves
    │   └── solutions/
    ├── W1D3_DigitalLogicMapping/           # Z2S Task 3: Gates, Adders, Muxes & Bit Widths
    │   ├── README.md
    │   ├── W1D3_Intro.ipynb
    │   ├── W1D3_Tutorial1.ipynb            # Mapping Python ops to Gate Diagrams
    │   └── W1D3_Tutorial2.ipynb            # Fixed-Point & Bit-Shift Approximations
    ├── W1D4_VerilogHardwareDesign/         # Z2S Tasks 4 & 5: Specs & Verilog Modules
    │   ├── README.md
    │   ├── W1D4_Intro.ipynb
    │   ├── W1D4_Tutorial1.ipynb            # Writing lif_chip_spec & Verilog Module
    │   └── W1D4_Tutorial2.ipynb            # Linting with Verilator in Colab
    └── W1D5_HardwareVerification/          # Z2S Task 6: Simulation, Waveforms & Co-Design
        ├── README.md
        ├── W1D5_Intro.ipynb
        ├── W1D5_Tutorial1.ipynb            # Running Testbenches & VCD Waveform Plotting
        ├── W1D5_Tutorial2.ipynb            # HW vs Python Comparison & Error Analysis
        └── W1D5_Outro.ipynb

---

3. Technical Proof-of-Concept: Running Verilog & Verilator in Colab

To make Verilog execution seamless inside NMA Google Colab notebooks without requiring local installations, use the following pattern in your tutorial cells:

Step 1: Install Hardware Tools in Colab Cell

# @title Toolchain Setup (Run this cell first)
# @markdown Installs Verilator and GTKWave utilities directly into the Colab environment.
!apt-get update -yq > /dev/null
!apt-get install -y verilator verilog > /dev/null
print("✅ Verilator & Icarus Verilog installed successfully!")

Step 2: Inline Verilog Module Creation

%%file lif_neuron.v
// @markdown ### Exercise: Complete the LIF Neuron Module
// @markdown Implement the non-blocking state update and threshold reset logic below.

module lif_neuron #(
    parameter WIDTH = 16,
    parameter V_TH = 16'd3800,   // -55 mV mapped to fixed-point
    parameter V_RESET = 16'd0,   // -70 mV offset to 0
    parameter TAU_INV = 16'd3    # Right-shift by 3
) (
    input wire clk,
    input wire rst,
    input wire [15:0] I_in,
    output reg [15:0] V_out,
    output reg spike
);

  always @(posedge clk) begin
    if (rst) begin
      V_out <= V_RESET;
      spike <= 1'b0;
    end else begin
      // Student Exercise: Fill in the LIF update equation and reset logic
      /* CODE FILL-IN START */
      if (V_out >= V_TH) begin
        spike <= 1'b1;
        V_out <= V_RESET;
      end else begin
        spike <= 1'b0;
        V_out <= V_out + ((I_in - V_out) >> TAU_INV);
      end
      /* CODE FILL-IN END */
    end
  end

endmodule

Step 3: Verilator Linting & C++ Testbench Execution in Notebook Cell

# @title Run Verilator Lint & Compile Testbench
!verilator --lint-only -Wall lif_neuron.v

Create C++ Testbench

%%file tb_lif_neuron.cpp
#include "Vlif_neuron.h"
#include "verilator.h"
#include <iostream>
#include <fstream>

int main(int argc, char** argv) {
    Verilated::commandArgs(argc, argv);
    Vlif_neuron* top = new Vlif_neuron;

    // Open VCD trace file
    Verilated::traceEverOn(true);

    top->clk = 0;
    top->rst = 1;
    top->I_in = 200;

    std::ofstream vcd("wave.csv");
    vcd << "cycle,V_out,spike\n";

    for (int cycle = 0; cycle < 100; cycle++) {
        top->clk = !top->clk;
        if (cycle > 4) top->rst = 0;
        top->eval();
        if (top->clk) {
            vcd << cycle/2 << "," << top->V_out << "," << (int)top->spike << "\n";
        }
    }
    std::cout << "Simulation complete. Waveform saved to wave.csv\n";
    delete top;
    return 0;
}

!verilator -Wall --cc --exe --build tb_lif_neuron.cpp lif_neuron.v
!./obj_dir/Vlif_neuron

Step 4: Rendering Waveforms with Matplotlib (NMA Style)

Rather than requiring desktop GTKWave, parse the output CSV/VCD and plot it using Neuromatch's standard xkcd or nma.mplstyle formatting:

# @title Plot Hardware Waveforms vs. Python Reference
import pandas as pd
import matplotlib.pyplot as plt

data = pd.read_csv("wave.csv")

with plt.xkcd():
  fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 6), sharex=True)
  
  ax1.plot(data["cycle"], data["V_out"], color="navy", label="Hardware V_out")
  ax1.axhline(y=3800, color="red", linestyle="--", label="V_th")
  ax1.set_ylabel("Membrane Potential (Fixed-Point)")
  ax1.legend(loc="upper right")
  
  ax2.step(data["cycle"], data["spike"], color="crimson", where="post", label="Spike Out")
  ax2.set_ylabel("Spike Output (Bit)")
  ax2.set_xlabel("Clock Cycle")
  ax2.set_ylim(-0.1, 1.1)
  ax2.legend(loc="upper right")
  
  plt.suptitle("Zero to Silicon: Hardware LIF Simulation Waveform")
  plt.show()

---

4. Updating Repository Configuration (tutorials/materials.yml)

NMA's build scripts read tutorials/materials.yml to construct the course syllabus, generate daily README.md files, and assemble the JupyterBook table of contents.

Update tutorials/materials.yml with the Zero to Silicon modules:

- day: W1D1
  category: Neuromorphic Hardware
  name: Biological & Conceptual Foundations
  tutorials: 1
  slides:
  - title: Intro to Neuromorphic Engineering
    link: https://open-neuromorphic.org/slides/w1d1_intro.pdf

- day: W1D2
  category: Neuromorphic Hardware
  name: Python LIF Reference Modeling
  tutorials: 1

- day: W1D3
  category: Digital Systems
  name: Logic Mapping & Bit-Width Analysis
  tutorials: 2

- day: W1D4
  category: Digital Systems
  name: Verilog Hardware Description
  tutorials: 2

- day: W1D5
  category: Digital Systems
  name: Verilator Simulation & Co-Design
  tutorials: 2

---

5. Actionable Roadmap for Team & Volunteer Onboarding

To address Justin's and Jose's notes on volunteer onboarding and project velocity, follow this phased rollout:

Phase 1: Prototype Proof-of-Concept (Current Week — Jose Antonio & Ray)

• Goal: Validate Colab execution of Verilator.
• Deliverable: Single notebook (sandbox_z2s_demo.ipynb) that runs Z2S Tasks 1–6 end-to-end in Google Colab (from Python LIF $\rightarrow$ Verilog compilation $\rightarrow$ CSV waveform plot).

Phase 2: Repository Rebranding & Structural Setup (Justin & Blair)

• Goal: Clean up the open-neuromorphic/course-content fork.
• Deliverable:
  • Update book/_config.yml with Open Neuromorphic logos, titles, and branding.
  • Populate tutorials/materials.yml with the Z2S day structure.
  • Run nmaci generate-readmes to build initial directory README files.

Phase 3: Volunteer Content Authoring (Community Onboarding)

• Goal: Enable volunteers to write individual tutorial notebooks without breaking CI/CD.
• Deliverable: Provide volunteers with a Tutorial Notebook Template containing NMA header tags:

  # @title Tutorial Header
  # @markdown Objective: Translate Python update rule to Verilog non-blocking assignments.

• Volunteers submit PRs targeting individual notebooks (tutorials/W1D4_VerilogHardwareDesign/W1D4_Tutorial1.ipynb). The GitHub Action notebook-pr.yaml will automatically test code execution and extract solution scripts.

[neural-loop]

📌 [Update] Zero to Silicon Series — Status & Sync Summary

1. Key Technical & Structural Decisions

• Platform Requirement (Google Colab): All final interactive exercises must run in Google Colab to avoid cross-platform local installation issues across participants (Windows/Mac/Linux). Tooling workflows requiring desktop UIs (e.g., full Tiny Tapeout / GTKWave UI) will be demonstrated via companion videos/pre-baked artifacts rather than blocking the core Colab path.
• Hardware Scope (Fully Digital): Confirmed the hardware track is 100% digital (ASIC-oriented minimal compute units modeling LIF membrane potentials and spike propagation). Analog and mixed-signal are strictly out of scope for this iteration.
• Format Alignment: Structuring modules after the Neuromatch format (lean notebooks with explicit prerequisites, narrative markdown, and runnable code blocks) to support potential future partnerships.
• Target Audience: Undergrad-level learners familiar with Python/basic ML, but assuming zero prior knowledge in computational neuroscience or chip design.
• Rollout Phases:
  1. Phase 1: Standalone Colab notebooks & markdown course materials.
  2. Phase 2: Embedded short video clips & desktop tooling walkthroughs.
  3. Phase 3: Community launch with live walkthroughs and Discord study channels.

---

2. Workstream Status

• Event 1 (Neuroscience Foundations & SNN Intro):

  • Theory: Bally completed the introductory neuroscience write-up (shared in Discord #zero-to-silicon and Google Drive).
  • Code: Peppermint is finalizing the companion code snippets.
  • Notebook Assembly: Effiong will merge Bally’s theory (as Markdown) and Peppermint’s code into the master Event 1 Colab notebook.

• Event 2+ (Hardware Design & Simulation):

  • Verilog/Verilator in Colab: Jose successfully tested running Verilog and Verilator inside a Colab notebook with Python-driven testbenches.
  • Curriculum & Tooling: Erastus is developing the step-by-step practices using local developer tools and evaluating Tiny Tapeout / Verilator.
  • Collaboration: Jose and Effiong will co-develop and split the end-to-end prototype into modular notebooks. Erastus will align his hardware designs with the digital Verilog structure in Jose’s prototype.

• QA & User Testing:

  • Malik Basit joined as a reviewer/tester to evaluate documentation clarity, prerequisite difficulty, and end-to-end flow from an ML background perspective.

---

3. Action Items

• Jose: Share the end-to-end prototype Colab notebook with Effiong and Erastus for review and alignment.
• Effiong: Combine Bally’s document and Peppermint’s code into the unified Event 1 Colab notebook.
• Erastus: Review Jose’s Colab implementation to ensure compatibility between local tooling workflows and Colab-executable Verilog.
• Bally / Peppermint: Confirm Event 1 resources are accessible in the shared drive / repo.
• Malik: Review initial drafts/notebooks upon release to provide QA feedback on learning curve and prerequisites.
• Justin: Organize repository workspaces/PR templates and coordinate next week's sync call (tentatively next Friday).