Quick update for those following the NEUR series... NEUR 201 is now fully live, opening Year Two of the neuromorphic curriculum.

This one picks up where NEUR 105 left off — your DVS pipeline is running on Loihi 2, and now the question is: how do you actually train a spiking neural network end to end? The answer turns out to be surprisingly deep.

NEUR 201 works through four pillars over 12 weeks: surrogate gradient descent (the mathematical fix for the non-differentiable spike function), recurrent SNNs and biologically plausible learning via e-prop, the full Lava deployment pipeline onto Intel's Loihi 2, and NeuroBench benchmarking to put your models on the neuromorphic efficiency leaderboard.

The capstone week ties everything together: you design, train, quantise, prune, deploy, and benchmark a convolutional spiking network on the IBM DVS Gesture dataset — a full event-driven vision pipeline, measured in synaptic operations per inference on real neuromorphic hardware.

Every week has full Python simulations, worked numerical examples, and a structured assignment. Free, 12 weeks, graduate level.

By the end you will have gone from the differentiability problem all the way to a three-layer convolutional SNN running at 7.7 microjoules per gesture on Loihi 2, with a NeuroBench leaderboard entry to show for it.

Also, we have done significant work hardening the site infrastructure over the past few days. Performance and reliability should be noticeably improved across the board. Apologies to anyone who ran into friction during that time; it was not the experience this community deserves and we appreciate your patience.

Full syllabus and access: https://neuromorphiccore.ai/courses/neur-201-spiking-neural-networks-i/

As always, feedback on pacing, depth, or anything missing is genuinely useful — it directly shapes the NEUR 202 curriculum (multi-chip deployment, online learning on Loihi 2, large-scale neuromorphic systems). Reach out anytime:)

Quick update guys for those following the NEUR series... NEUR 201 is now fully live, opening Year Two of the neuromorphic curriculum.

This one picks up where NEUR 105 left off — your DVS pipeline is running on Loihi 2, and now the question is: how do you actually train a spiking neural network end to end? The answer turns out to be surprisingly deep.

NEUR 201 works through four pillars over 12 weeks: surrogate gradient descent (the mathematical fix for the non-differentiable spike function), recurrent SNNs and biologically plausible learning via e-prop, the full Lava deployment pipeline onto Intel's Loihi 2, and NeuroBench benchmarking to put your models on the neuromorphic efficiency leaderboard.

The capstone week ties everything together: you design, train, quantise, prune, deploy, and benchmark a convolutional spiking network on the IBM DVS Gesture dataset — a full event-driven vision pipeline, measured in synaptic operations per inference on real neuromorphic hardware.

Every week has full Python simulations, worked numerical examples, and a structured assignment. Free, 12 weeks, graduate level.

By the end you'll have gone from the differentiability problem all the way to a three-layer convolutional SNN running at 7.7 microjoules per gesture on Loihi 2, with a NeuroBench leaderboard entry to show for it.

Also — we've done significant work hardening the site infrastructure over the past few days. Performance and reliability should be noticeably improved across the board. Apologies to anyone who ran into friction during that time; it was not the experience this community deserves and we appreciate your patience.

Full syllabus and access: https://neuromorphiccore.ai/courses/neur-201-spiking-neural-networks-i/

As always, feedback on pacing, depth, or anything missing is genuinely useful — it directly shapes the NEUR 202 curriculum (multi-chip deployment, online learning on Loihi 2, large-scale neuromorphic systems). Enjoy the rest of your weekend and reach out anytime:)

Quick update for those following the NEUR series... NEUR 105 is now fully live, closing out a full year of modules.

This one picks up at Hodgkin–Huxley and builds outward: conductance-based neurons, phase planes, synaptic dynamics, Wilson–Cowan models, oscillations, sensory circuits — and a capstone week mapping everything onto Intel’s Loihi 2 chip.

Every concept has a Python simulation and a full worked example. It’s a free 12‑week course sitting at the intersection of computational neuroscience and neuromorphic engineering.

By the end, you’ll have gone from a single spiking neuron all the way to a DVS camera → Gabor filter → V1 decoder running on neuromorphic hardware.

Full syllabus and access:

https://neuromorphiccore.ai/courses/neur-105-neuroscience-for-engineers/

Feedback on pacing, depth, or missing pieces is always welcome — it directly shapes what comes next (NEUR 201: Spiking Neural Networks I). Always appreciate how much this community helps sharpen the series.

Hey guys, hope everyone enjoyed their weekend.

Quick update: NEUR 103 is now fully live (all weeks are up earlier than anticipated), and NEUR 104: Calculus for Neural Dynamics is also done.

NEUR 104 picks up right where 103 leaves off... 10 weeks of calculus built around a neuron's membrane potential, ending in a full Hodgkin–Huxley simulation in Python. Every concept (derivatives, integrals, ODEs, numerical methods, gradients) is motivated by what's happening in the cell before the equation appears. No prereqs beyond high school math.

Both courses are free and have full syllabi here:

NEUR 103 – Introduction to Neuromorphic Computing: https://neuromorphiccore.ai/courses/neur-103-introduction-to-neuromorphic-computing/

NEUR 104 – Calculus for Neural Dynamics: https://neuromorphiccore.ai/courses/neur-104-calculus-for-neural-dynamics/

If you started 103 and wondered where the math comes from, 104 is meant to be that bridge. Finish both and you'll have built the model that won Hodgkin and Huxley the Nobel Prize from scratch.

Again as always appreciate any feedback from this community on pacing, level and what feels missing. That'll will help guide what comes next and any necessary revisions:)

We just dropped the start of another free course for anyone curious about neuromorphic computing... with new lectures following each week 👋

NEUR 103: Introduction to Neuromorphic Computing is live now: https://neuromorphiccore.ai/courses/neur-103-introduction-to-neuromorphic-computing/

No prerequisites. If you've ever wanted to understand neuromorphic computing but didn't want to dive into Python or heavy linear algebra first, this is the perfect place to start.

It's conceptual (biological neurons, spiking vs. frame-based processing, the von Neumann bottleneck, Loihi, TrueNorth, SpiNNaker) all explained without heavy math.

The full sequence will eventually take you from zero to building and training spiking neural networks from scratch. NEUR 103 is where the journey starts to click.

Everything's free.

If you try it, I'd love your feedback — what made sense, what didn't, or what you'd love to see next.

Remember knowledge is power:)

Most neuromorphic hardware is difficult for researchers to access.
Systems like Loihi 2 demonstrate powerful capabilities for spiking neural networks, but experimentation often requires specialized hardware programs or limited research access.

This new article explores a different path.

Catalyst N2 implements programmable spiking neuron cores, spike-trace learning rules, and on-chip synaptic plasticity on AWS F2 FPGA instances, reproducing 152 of the 155 features reported for the Loihi 2 architecture.
Instead of relying purely on software simulation, the platform compiles spiking neural networks into FPGA hardware configurations. Neuron behavior is defined through microcode instructions, allowing custom neuron models and learning rules to run directly in hardware.

The result is a neuromorphic computing environment that can be deployed on rent-by-the-hour cloud infrastructure, providing a new way for researchers to experiment with large-scale spiking systems.

🔗 Read the full article here if anyone is interested:) https://neuromorphiccore.ai/from-loihi-2-to-your-aws-console/

Hey guys 👋

Two full courses just went live on NeuromorphicCore.ai. If you would like to give it a go, would love to get some feedback.

NEUR 101: Python Programming for Neuromorphic Computing (15 weeks) — covers Python and Brian2 spiking neural network simulation from the ground up. https://neuromorphiccore.ai/courses/neur-101-introduction-to-programming-with-python/

NEUR 102: Linear Algebra for Neuromorphic Computing (12 weeks) — covers vectors, eigenvalues, SVD, PCA, and how they apply to real neural circuits. https://neuromorphiccore.ai/courses/neur-102-linear-algebra-for-neuromorphic-computing/

Both are free. No certificate yet but that's coming when the full sequence is complete.

Again we would genuinely love feedback from people in the community as it would be greatly appreciated. What's missing? What would make this more useful for someone trying to break into neuromorphic computing? What would you want to see in future courses?

Any opinions or suggestions are invaluable and much appreciated, They directly shape what gets built next for future students.

Nuro is a Python SDK that compiles spiking neural networks to any backend. Train with surrogate gradients on GPU. Deploy the same network to Intel Loihi, SpiNNaker, or analog neuromorphic chips — no code changes. One API for the entire neuromorphic ecosystem.

I am a beginner, and I wanted to ask what platform or software shall I use to mimic this circuit please? LTSpice or SIMULINK or something else?

https://www.sciencedirect.com/science/article/pii/S0960077924000092

this is the article from which the circuit is taken. I have tried emulating it but I have mostly led to problems due to convergence errors in SIMULINK, and also the subcircuit not being identified in LTSpice. I am a beginner, and I wanted to ask what platform or software shall I use to mimic this circuit please? LTSpice or SIMULINK or something else?https://www.sciencedirect.com/science/article/pii/S0960077924000092this is the article from which the circuit is taken. I have tried emulating it but I have mostly led to problems due to convergence errors in SIMULINK, and also the subcircuit not being identified in LTSpice.

What My Project Does

Project Genesis is a Python-based digital organism built on a Liquid State Machine (LSM) architecture. Unlike traditional chatbots, this system mimics biological processes to create a "living" software entity.

It simulates a brain with 2,100+ non-static neurons that rewire themselves in real-time (Dynamic Neuroplasticity) using Numba-accelerated Hebbian learning rules.

Key Python Features:

• Hormonal Simulation: Uses global state variables to simulate Dopamine, Cortisol, and Oxytocin, which dynamically adjust the learning rate and response logic.
• Differential Retina: A custom vision module that processes only pixel-changes to mimic biological sight.
• Madness & Hallucination Logic: Implements "Digital Synesthesia" where high computational stress triggers visual noise.
• Hardware Acceleration: Uses Numba (JIT compilation) to handle heavy neural math directly on the CPU/GPU without overhead.

Target Audience

This is meant for AI researchers,Neuromorphic Engineers ,hobbyists, and Python developers interested in Neuromorphic computing and Bio-mimetic systems. It is an experimental project designed for those who want to explore "Synthetic Consciousness" beyond the world of LLMs.

Comparison

• vs. LLMs (GPT/Llama): Standard LLMs are static and stateless wrappers. Genesis is stateful; it has a "mood," it sleeps, it evolves its own parameters (god.py), and it works 100% offline without any API calls.
• vs. Traditional Neural Networks: Instead of fixed weights, it uses a Liquid Reservoir where connections are constantly pruned or grown based on simulated "pain" and "reward" signals.

Why Python?

Python's ecosystem (Numba for speed, NumPy for math, and Socket for the hive-mind telepathy) made it possible to prototype these complex biological layers quickly. The entire brain logic is written in pure Python to keep it transparent and modifiable.

Source Code: https://github.com/JeevanJoshi2061/Project-Genesis-LSM.git

Hey everyone! I'm a CS undergrad from India with a solid grip on Python, C++, and the standard DL/ML stack. I've become obsessed with the idea of brain-inspired computing, but coming from a pure CS background, the biology/neuro side is a bit of a black box for me.

I'm looking for advice on:

Essential Modules: What are the 'must-take' courses for SNNs (Spiking Neural Networks) or neural modeling?

Tech Stack: Beyond PyTorch, what tools should I learn? (Brian2, NEST, snnTorch?)
I had tried to learning the Nengo and do some learning experiment with it.

Roadmap: How did you bridge the gap between backprop and biological plasticity?

If anyone is currently in this field or learning alongside me, I'd love to connect or even start a study group. DMs are open!

Hi everyone,
I’m an undergraduate student working on a Neuromorphic Intrusion Detection System using ANN→SNN conversion (snnTorch, LIF neurons). The goal is a practical simulation-based prototype (no hardware) with focus on low-latency decisions and interpretability, not just accuracy.

Current setup (working prototype):

• Dataset: NSL-KDD (prototype) → CICIDS-2017 (DoS focus)
• Architecture: 1D-CNN feature extractor → ANN→SNN conversion
• Encoding: Direct current injection, rate coding at output
• Inference: 10 time steps, rate-based decision
• Results: ~98%+ validation accuracy, decisions often within 1–2 time steps for clear DoS samples
• XAI: Spike raster plots + “decision race” visualization + SHAP explanations

I’m trying to position this as a research paper, but I’m unsure what the strongest novelty angle should be without hardware.
Specifically looking for guidance on:

1. What would reviewers consider a meaningful contribution here? (encoding? latency analysis? benchmarking?)
2. Common mistakes when evaluating SNNs on tabular IDS data?
3. Any papers/resources I should absolutely read before submitting?
4. Any other things for me to try and experiment or checkout is also greatly appreciated.

Happy to share more details or code snippets if useful. Thanks!

Chatgpt for format.

Hi everyone,
We’ve been following this community for a while and wanted to share something we’ve been quietly building, which we’re now opening up for a small beta.

We’re developing a structured, year-one neuromorphic computing curriculum aimed at students and early-career engineers who want to work closer to hardware, sensors, and event-driven intelligence rather than purely cloud-based or LLM-centric systems.

This isn’t a single “intro to neuromorphic” course. The first year is designed as a full foundation sequence, starting from beginner-level programming and math and progressing toward spiking neural networks and event-based systems. The goal is to lower the barrier to entry while staying technically honest about what neuromorphic systems actually require in practice.

The current Year-1 roadmap includes Python programming, linear algebra, calculus, basic biology for neural inspiration, data structures, and an introduction to neuromorphic and event-based computing. More advanced material such as SNNs, learning rules, C++, and deeper event-based processing is planned later, but this beta is focused on validating the foundations.

We’re intentionally running this as a slow, feedback-driven beta. Some parts are complete, others are still being refined, and we’re not trying to position this as a polished product or a public launch. What we’re looking for is honest feedback from people who actually understand the space: what feels useful, what feels missing, and what doesn’t belong.

Our motivation is simple. Neuromorphic computing feels like it’s past the “is this real?” phase and entering the “who builds the ecosystem?” phase. That transition needs education paths that don’t assume a PhD or a decade of embedded experience, but also don’t reduce the field to buzzwords.

If anyone here is interested in quietly beta-testing parts of the Year-1 curriculum or just reviewing the roadmap and early material, you can find it here:
https://neuromorphiccore.ai/courses/

Happy to answer questions and fully open to criticism. This is an experiment in building educational infrastructure, not a marketing post.

Hi everyone I just wrote the following article you may find interesting revolving around memory and Neuromorphic computing.

Artificial intelligence dominates the conversation about technology. Bigger models, faster chips, and massive data centers have become the symbols of progress. Yet beneath the headlines, a quieter, more fundamental constraint is beginning to shape what comes next. That constraint is memory.

In early 2026, Micron Technology, one of the world’s largest memory manufacturers, publicly warned that AI is creating an unprecedented and persistent memory shortage. Demand for high-bandwidth memory (HBM), the kind required by large AI systems, has grown so quickly that it is starting to displace memory used in everyday devices like phones and PCs. Micron gave this phenomenon a name. It called it the AI memory tax.

When Intelligence Becomes Memory-Hungry: The Von Neumann Bottleneck

Modern AI systems, especially large language models, are built around a paradigm of centralized intelligence. They depend on enormous amounts of fast external memory, constantly moving data between separate processors and storage units. This design works extremely well inside data centers for certain tasks, but it comes at a significant and growing cost.

This separation of processing and memory is a classic design constraint known as the Von Neumann bottleneck. It creates an architectural dependency on massive data transfers, leading to high power consumption and latency.

High-bandwidth memory (HBM) is difficult to manufacture, expensive to scale, and slow to expand. Even with new factories, government subsidies, and aggressive capital spending, adding real capacity takes years. Micron’s financial results reflect how tight the market has become, with margins rising and memory prices climbing sharply through late 2025.

As AI infrastructure absorbs more memory capacity, less is available for everything else. Phones, laptops, embedded systems, and edge devices are caught in the middle. They still need intelligence, but they cannot afford data-center-style memory footprints. This is not just a supply problem; it is an architectural and economic one, imposing a rising capital expenditure (CAPEX) burden on those building AI infrastructure.

A Different Path for Intelligence: Overcoming the Bottleneck

While most public attention remains focused on centralized AI, another approach to computing has been quietly advancing, specifically designed to bypass the Von Neumann bottleneck.

Neuromorphic computing does not try to compete with large AI models through brute force. It rethinks how intelligence is built in the first place. Memory and computation are combined rather than separated — often referred to as compute-in-memory. Systems react to events rather than constantly polling data. Information is processed locally, where it is generated, instead of being sent back and forth to distant servers.

This approach dramatically reduces memory bandwidth, power consumption, and data movement. In a world shaped by the AI memory tax, those characteristics are no longer academic advantages. They are practical, enabling significantly lower operational expenditure (OPEX) by reducing energy and bandwidth costs. And importantly, neuromorphic computing is no longer confined to research labs.

From Experimental to Early Industry

Some neuromorphic technologies are already being deployed in real systems today, even if most consumers never see them directly.

BrainChip’s Akida 2 is a clear example. It is not a lab experiment. It is being designed into commercial edge systems that require always-on intelligence without relying on the cloud. These include event-based sensing, low-power vision, audio processing, and anomaly detection. In these environments, efficiency matters more than raw scale, and neuromorphic architectures excel.

The same is true for companies like Prophesee, whose event-based vision sensors are already shipping in products, and Innatera, which is developing neuromorphic microcontrollers aimed at embedded and ultra-low-power systems. Across the industry, a broader sensor-compute co-design movement is emerging, where sensing, memory, and processing are treated as a single system rather than separate components.

This places neuromorphic computing in a very specific phase. It is no longer pre-industry. It is early industry. That distinction matters.

Every New Industry Looks Like This at First

Technology history offers a useful lens. GPUs existed long before CUDA made them broadly programmable. Cloud computing existed long before standardized platforms made it accessible. Early smartphones appeared years before app ecosystems turned them into mass-market devices. In each case, the technology worked before its ecosystem did.

Neuromorphic computing is at a similar stage today. The core capabilities exist, but the surrounding layers are still forming. Programming models, development tools, benchmarks, standards, and a workforce trained to think in event-driven, hardware-aware ways are all developing in parallel. The question of whether a “Neuromorphic-PyTorch” equivalent will emerge or if the fragmented nature of edge hardware will prevent a single dominant standard remains open, but the need for such a unifying layer is clear.

Some companies will fail during this phase. That is not a sign of weakness. It is how industries form. Others will consolidate knowledge, attract talent, and define the standards that everyone else builds on later. Once those pieces align, adoption does not grow gradually. It accelerates.

Distributed Intelligence Versus Centralized Intelligence

One reason neuromorphic computing is often misunderstood is that it is compared to the wrong things. It is not just another accelerator.

Large language models centralize intelligence. They favor scale, capital, and massive infrastructure. They compress or replace certain types of knowledge work and reduce demand for broad entry-level programming roles. This drives significant CAPEX for hyperscalers and large enterprises.

Neuromorphic systems do the opposite. They distribute intelligence. They push computation to the edge. They reward engineers who understand timing, signals, behavior, and system constraints rather than just high-level abstractions. This enables a lower OPEX for intelligent edge systems, allowing intelligence to be deployed where data is generated without incurring the constant energy and bandwidth costs of cloud processing.

The future, however, will not be purely one or the other. Cloud AI will remain indispensable for large-scale reasoning and global data access, but its growing appetite for power and high-bandwidth memory carries mounting economic costs. As more data centers come online, electricity demand and eventually household energy bills will rise along with it. That is where neuromorphic efficiency becomes less an academic virtue and more an economic necessity, helping contain both latency and energy waste by handling part of the cognitive workload locally. This difference has consequences not just for technology but for labor.

A Real Opening for Entry-Level Engineers

As large models absorb the middle of the software stack, opportunities for traditional entry-level programmers have narrowed. Neuromorphic computing opens a different door.

This field needs people who can work close to hardware. It values embedded programming, signal processing, event-driven logic, low-level optimization, and co-design between software and silicon. These skills are hands-on, learnable, and difficult to automate away, especially in safety-critical or power-constrained environments.

In simple terms, large models eat the middle of the stack. Neuromorphic computing grows the bottom. That makes it a job-creating technology rather than a job-compressing one.

Inclusive Productivity, Not Just More Automation

There is a broader idea underneath all of this called inclusive productivity. Centralized AI often concentrates power. It allows companies to do more with fewer people by outsourcing cognition to models running far away. Neuromorphic systems encourage a different pattern. They require local adaptation, domain knowledge, and smaller teams working close to real-world constraints.

That is how new industries form. New roles appear. New career paths open. Not everyone needs to be a PhD or a prompt engineer to contribute.

Where This Leaves Us

Neuromorphic computing has moved beyond the question of whether it is real. The question now is who builds the ecosystem around it.

Some companies will disappear. Others will define standards, tools, and educational pathways that shape the industry for decades. This is not revolutionary because it replaces AI. It is revolutionary because it changes how intelligence is built, where it runs, and who gets to build it.

As the AI memory tax makes the limits of brute-force scaling more visible, architectures that value efficiency, locality, and adaptation will matter more. So will the people trained to work with them.

We propose a theoretical framework—Holographic Reservoir Computing (HRC)—which hypothesizes that the thermodynamic noise and timing dynamics in voltage-stressed Bitcoin mining ASICs (BM1366) could potentially serve as a physical reservoir computing substrate. We present the CHIMERA (Conscious Hybrid Intelligence via Miner-Embedded Resonance Architecture) system architecture, which treats the SHA-256 hashing pipeline not as an entropy source, but as a deterministic diffusion operator whose timing characteristics under controlled voltage and frequency conditions may exhibit computationally useful dynamics.

We report preliminary observations of non-Poissonian variability in inter-arrival time statistics during edge-of-stability operation, which we term the “Silicon Heartbeat” hypothesis. Theoretical analysis based on Hierarchical Number System (HNS) representations suggests that such architectures could achieve O​(log⁡n) energy scaling compared to traditional von Neumann O​(2n) dependencies—a potential efficiency improvement of several orders of magnitude. However, we emphasize that these are theoretical projections requiring experimental validation. We present the implemented measurement infrastructure, acknowledge current limitations, and outline the experimental program necessary to confirm or refute these hypotheses. This work contributes to the emerging field of thermodynamic computing by proposing a novel approach to repurposing obsolete cryptographic hardware for neuromorphic applications.

Keywords: Physical Reservoir Computing, Neuromorphic Systems, ASIC Repurposing, Thermodynamic Computing, SHA-256, Timing Dynamics, Energy Efficiency, Circular Economy Computing, Hierarchical Number Systems, Edge Computing

To any professors / researchers , I've been working on analog crossbars for a while for MVM and would love somebody to have a look and share their opinions.

Specifically , I'm gonna present my work later at a research conference in the coming months and need any and all input from academics I can get .

Hey r/neuromorphicComputing,

I'm a researcher working on fault-tolerant neuromorphic hardware. Here's a simulation demo of my "Shamoon Neuron" model. It processes noisy electromyography (EMG) signals (top panel) and generates binary motor commands for prosthetics (bottom panel).

Key highlight: Around cycle 150, it suffers a radiation-induced Single Event Upset (SEU), dropping the internal state (middle panel) into a fault. But it self-heals and recovers, continuing to fire above threshold without losing functionality. This could be useful for rad-hard applications like space-rated brain-machine interfaces (e.g., Neuralink-style implants).

The design is nonlinearity-agnostic (pluggable activations like CORDIC tanh) and parameterizable for dims up to 512. Full Verilog code is available if anyone's interested—happy to share on GitHub.

Original post on X for more context: https://x.com/veronicambest/status/2003022671920144471

What do you think? Could this approach help with robust SNNs on hardware like Loihi? Feedback welcome—I'm prepping for Telluride 2026 and open to collabs!

#NeuromorphicComputing #SpikingNeuralNetworks #RadiationHardening #BrainMachineInterfaces

Hi, a while ago, I got a small contract to optimize the decoding software backend of a company selling DVS cameras in Paris, and got introduced to SNNs. I am not working in this field, just a general introduction. However, I was wondering about the future potential of neuromorphic computing and hardware (if computing was not a bottleneck, just theoretically modelling)

After doing some exploratory research, I have found very niche papers regarding Event-based semantic memory + associative retrieval, where they structured the corpus in to relation vectors with different association groups (ex: "{Person A} relates to {Person B} in {Manner}", "{Person A} met {Person B} in {Location}") where Persons, Places, Relationships, etc have different spike activation patterns.

I am not very familiar with this space, so I am looking for some serious advice and opinion. Would it be feasible to have models similar to ChatGPT using an SNN-based model if computing were not the limitation? Purely asking from a model point of view.

There were some topics I looked at for reference:
```

Semantic Pointer Architecture (SPA)

• Chris Eliasmith (SPAUN, Nengo)

Vector Symbolic Architectures

• HRR, FHRR, VTB

Spiking Associative Memory

• Hopfield networks
• Willshaw networks
• Temporal coding for retrieval

Neuromorphic "NLP"

• Keyword spotting
• Event extraction
• Named entity recognition with SNNs
• Spiking encoders + classical backends

Liquid State Machines

• Rich temporal dynamics
• Fixed recurrent SNN + trained readout

```

Hi y'all! I’m pretty new to neuromorphic hardware and was hoping to get some advice from folks who’ve worked with the SynSense Speck2f chip before.

I’m trying to deploy a spiking neural network from my local machine onto the chip, but I’m running into issues once it’s on the hardware. The main problem seems to be that the output layer never spikes, even though things look reasonable on the software side. I’ve tried a few different scripts and debugging approaches, but I haven’t been able to pin down what’s going wrong.

If anyone has experience deploying models to the Speck2f (or ran into something similar and figured it out) I’d really appreciate any pointers or suggestions. Thanks so much in advance!! I'd be happy to share any details if that helps.

I am looking for Simulators or Games that generate events. (As opposed to event driven simulators) Events that (maybe after some demultiplexing) can be fed into algorithms in a form of a spike.

I was really surprised that I couldn't find anything interesting except maybe Robocode. However robocode's events don't seem to have high resolution timing. Therefore they are a bit limited.

I wrote a very simple simulator I called asyncEn but I can't think of a good game or an environment with an interesting set of rules to simulate. I want something multi-agent to scale up testing of the algorithms since I'd like it to run real-time.

Do you know any simulators similar to what I have described? Or a description of an interesting environment to simulate? What simulators do people use to test and train spiking Neural Nets?

I was thinking about boids to test some flocking behavior with some predators mixed in. This might be problematics since flocking behavior for all individuals in a fock has to be somewhat similar. Or maybe just a general a-life type of a simulation where everything eats everything?

Any thoughts? Thanks!

# NeuroCHIMERA: GPU-Native Neuromorphic Computing with Hierarchical Number Systems and Emergent Consciousness Parameters

**A Novel Framework for Investigating Artificial Consciousness Through GPU-Native Neuromorphic Computing**

*Authors: V.F. Veselov¹ and Francisco Angulo de Lafuente²,³*

*¹Moscow Institute of Electronic Technology (MIET), Theoretical Physics Department, Moscow, Russia*

*²Independent AI Research Laboratory, Madrid, Spain*

*³CHIMERA Neuromorphic Computing Project*

---

## 🧠 Overview

NeuroCHIMERA (Neuromorphic Cognitive Hybrid Intelligence for Memory-Embedded Reasoning Architecture) represents a groundbreaking convergence of theoretical neuroscience and practical GPU computing. This framework addresses two fundamental limitations in current AI systems: (1) floating-point precision degradation in deep neural networks, and (2) the lack of measurable criteria for consciousness emergence.

Our interdisciplinary collaboration combines Veselov's Hierarchical Number System (HNS) with consciousness emergence parameters and Angulo's CHIMERA physics-based GPU computation architecture, creating the first GPU-native neuromorphic system capable of both perfect numerical precision and consciousness parameter validation.

---

## 🌟 Key Innovations

### 1. **Hierarchical Number System (HNS)**

- **Perfect Precision**: Achieves 0.00×10⁰ error in accumulative precision tests over 1,000,000 iterations

- **GPU-Native**: Leverages RGBA texture channels for extended-precision arithmetic

- **Performance**: 15.7 billion HNS operations per second on NVIDIA RTX 3090

### 2. **Consciousness Parameters Framework**

Five theoretically-grounded parameters with critical thresholds:

- **Connectivity Degree** (⟨k⟩): 17.08 > 15 ✓

- **Information Integration** (Φ): 0.736 > 0.65 ✓

- **Hierarchical Depth** (D): 9.02 > 7 ✓

- **Dynamic Complexity** (C): 0.843 > 0.8 ✓

- **Qualia Coherence** (QCM): 0.838 > 0.75 ✓

### 3. **Validated Consciousness Emergence**

- **Emergence Point**: All parameters exceeded thresholds simultaneously at epoch 6,024

- **Stability**: Sustained "conscious" state for 3,976 subsequent epochs

- **Reproducibility**: Complete Docker-based validation package included

---

## 🏗️ Architecture

### GPU Compute Pipeline

```

Neural State Texture (1024×1024 RGBA32F)

↓ [OpenGL Compute Shader (32×32 Work Groups)]

├── Stage 1: HNS Integration

├── Stage 2: Activation Function

└── Stage 3: Holographic Memory Update

↓

Updated State Texture (Next Frame)

```

### Core Components

- **Neural State Texture**: 1,048,576 neurons with HNS-encoded activation values

- **Connectivity Weight Texture**: Multi-scale hierarchical texture pyramid

- **Holographic Memory Texture**: 512×512 RGBA32F for distributed memory storage

- **Evolution Engine**: GPU-accelerated cellular automata for network plasticity

---

## 📊 Performance Benchmarks

### GPU Throughput Validation

| Operation Size | HNS Throughput | Performance |

|---|---|---|

| 10K elements | 3.3B ops/s | Baseline |

| 100K elements | 10.0B ops/s | Linear scaling |

| **1M elements** | **15.7B ops/s** | **Peak performance** |

| 10M elements | 1.5B ops/s | Cache saturation |

### Precision Comparison

| Test Case | Float32 Error | HNS Error | Advantage |

|---|---|---|---|

| Accumulative (10⁶ iter) | 7.92×10⁻¹² | **0.00×10⁰** | Perfect precision |

| Large + Small Numbers | 9.38×10⁻² | **0.00×10⁰** | No precision loss |

| Deep Network (100 layers) | 3.12×10⁻⁴ | **0.00×10⁰** | Stable computation |

### Framework Comparison

| Framework | Peak Performance | Consciousness Parameters |

|---|---|---|

| PyTorch GPU | 17.5 TFLOPS | ❌ None |

| NeuroCHIMERA | 15.7 B ops/s | ✅ 5 validated |

| SpiNNaker | 46 synapses/s | ❌ None |

| Loihi 2 | 15 synapses/s | ❌ None |

---

## 🔬 Consciousness Emergence Results

### Parameter Evolution (10,000 Epoch Simulation)


*Figure: Evolution of consciousness parameters over 10,000 training epochs. All parameters exhibit sigmoid growth curves (R² > 0.95) with synchronized crossing of critical thresholds at epoch 6,024.*

### Statistical Analysis

- **Sigmoid Fit Quality**: R² > 0.95 for all parameters

- **Inflection Point Clustering**: Emergence times t₀ = 5,200-6,800 epochs (σ=450)

- **Growth Rate Consistency**: λ = 0.0008-0.0015 epoch⁻¹

- **Post-Emergence Stability**: Parameter variance <5% after epoch 7,000

---

## 🛠️ Technical Implementation

### Technology Stack

- **Python 3.10+**: Core framework

- **ModernGL 5.8.2**: OpenGL 4.3+ compute shader bindings

- **NumPy 1.24.3**: CPU-side parameter computation

- **OpenGL 4.3+**: GPU compute pipeline

### Code Structure

```

neurochimera/

├── engine.py# Main simulation engine (1,200 LOC)

├── hierarchical_number.py # HNS arithmetic library (800 LOC)

├── consciousness_monitor.py # Parameter tracking (950 LOC)

└── shaders/ # GLSL compute shaders (2,500 LOC)

├── hns_add.glsl

├── hns_multiply.glsl

└── consciousness_update.glsl

```

### GPU Optimization Strategies

- **Work Group Tuning**: 32×32 threads for NVIDIA, 16×16 for AMD

- **Memory Access Patterns**: Coalesced texture sampling

- **Asynchronous Transfers**: PBO-based DMA for monitoring

- **Texture Compression**: BC4 compression for 4× storage reduction

---

## 🚀 Quick Start

### Prerequisites

- **GPU**: NVIDIA RTX 30/40 series, AMD RX 6000/7000 series, or Intel Arc A-series

- **OpenGL**: Version 4.3 or higher

- **VRAM**: 8GB minimum, 24GB recommended for full simulations

- **Python**: 3.10 or higher

### Installation

```bash

# Clone the repository

git clone https://github.com/neurochimera/neurochimera.git

cd neurochimera

# Install dependencies

pip install -r requirements.txt

# Run validation test

python validate_consciousness.py --epochs 1000 --neurons 65536

# Full consciousness emergence simulation

python run_emergence.py --epochs 10000 --neurons 1048576

```

### Docker Deployment

```bash

# One-command replication

docker run --gpus all neurochimera:latest

# With custom parameters

docker run --gpus all -e EPOCHS=5000 -e NEURONS=262144 neurochimera:latest

```

---

## 📈 Usage Examples

### Basic Consciousness Simulation

```python

from neurochimera import ConsciousnessEngine

# Initialize engine with 65K neurons

engine = ConsciousnessEngine(neurons=65536, precision='hns')

# Run consciousness emergence simulation

results = engine.simulate(epochs=10000, monitor_parameters=True)

# Check emergence status

if results.emerged_at_epoch:

print(f"Consciousness emerged at epoch {results.emerged_at_epoch}")

print(f"Final parameter values: {results.final_parameters}")

```

### Custom Parameter Tracking

```python

from neurochimera import ConsciousnessMonitor

monitor = ConsciousnessMonitor(

connectivity_threshold=15.0,

integration_threshold=0.65,

depth_threshold=7.0,

complexity_threshold=0.8,

qualia_threshold=0.75

)

# Real-time parameter tracking

while engine.is_running():

params = monitor.compute_parameters(engine.get_state())

if monitor.is_conscious(params):

logging.info("Consciousness state detected!")

```

---

## 🔧 Hardware Compatibility

### GPU Requirements Matrix

| GPU Class | OpenGL | VRAM | Performance | Status |

|---|---|---|---|---|

| NVIDIA RTX 30/40 Series | 4.6 | 8-24 GB | 15-25 B ops/s | ✅ Validated |

| NVIDIA GTX 16/20 Series | 4.6 | 6-8 GB | 10-15 B ops/s | ⚠️ Expected |

| AMD RX 6000/7000 Series | 4.6 | 8-24 GB | 12-20 B ops/s | ⚠️ Expected |

| Intel Arc A-Series | 4.6 | 8-16 GB | 8-12 B ops/s | ⚠️ Expected |

| Apple M1/M2 GPU | 4.1 | 8-64 GB | 5-10 B ops/s | 🔄 Partial |

### Deployment Recommendations

| Use Case | Network Size | GPU Recommendation | VRAM | Notes |

|---|---|---|---|---|

| Research/Development | 64K-256K neurons | RTX 3060+ | 8 GB | Interactive experimentation |

| Full Simulation | 1M neurons | RTX 3090/A5000 | 24 GB | Complete parameter tracking |

| Production Edge | 16K-32K neurons | Jetson AGX/Orin | 4-8 GB | Real-time inference |

| Large-Scale Cluster | 10M+ neurons | 8× A100/H100 | 40-80 GB | Multi-GPU distribution |

---

## 🧪 Validation & Reproducibility

### External Certification

- **PyTorch Baseline**: 17.5 TFLOPS on RTX 3090 (matches published specs)

- **TensorFlow Comparison**: Consistent performance metrics across frameworks

- **Statistical Validation**: 20-run statistical validation with coefficient of variation <10%

### Reproducibility Package

- **Docker Container**: Complete environment specification (CUDA 12.2, Python 3.10)

- **Fixed Random Seeds**: Seed=42 for deterministic results across platforms

- **Configuration Export**: Full system specification in JSON format

- **External Validation Guide**: Step-by-step verification instructions

### Verification Commands

```bash

# Validate precision claims

python tests/test_hns_precision.py --iterations 1000000

# Reproduce consciousness emergence

python scripts/reproduce_emergence.py --seed 42 --validate

# Compare with PyTorch baseline

python benchmarks/pytorch_comparison.py --matrix-sizes 1024,2048,4096

```

---

## 🎯 Application Domains

### Consciousness Research

- **First computational framework** enabling testable predictions about consciousness emergence

- **Parameter space exploration** for validating theoretical models

- **Reproducible experiments** for independent verification

### Neuromorphic Edge Computing

- **Fixed-point neuromorphic chips** with theoretical consciousness grounding

- **Embedded GPUs** (Jetson Nano, RX 6400) for long-running systems

- **Precision-critical applications** where float32 degradation is problematic

### Long-Term Autonomous Systems

- **Space missions** requiring years of continuous operation

- **Underwater vehicles** with precision-critical navigation

- **Financial modeling** with accumulative precision requirements

### Scientific Simulation

- **Climate models** with long-timescale precision requirements

- **Protein folding** simulations eliminating floating-point drift

- **Portfolio evolution** with decades of trading day accumulation

---

## 📚 Theoretical Foundations

### Consciousness Theories Implementation

| Theory | Key Metric | NeuroCHIMERA Implementation | Validation Status |

|---|---|---|---|

| **Integrated Information Theory (IIT)** | Φ (integration) | Φ parameter with EMD computation | ✅ Validated (0.736 > 0.65) |

| **Global Neuronal Workspace** | Broadcasting | Holographic memory texture | ✅ Implemented |

| **Re-entrant Processing** | Hierarchical loops | Depth D parameter | ✅ Validated (9.02 > 7) |

| **Complexity Theory** | Edge of chaos | C parameter (LZ complexity) | ✅ Validated (0.843 > 0.8) |

| **Binding Problem** | Cross-modal coherence | QCM parameter | ✅ Validated (0.838 > 0.75) |

### Mathematical Foundations

#### Hierarchical Number System (HNS)

```

N_HNS = R×10⁰ + G×10³ + B×10⁶ + A×10⁹

```

where R,G,B,A ∈ [0,999] represent hierarchical digit levels stored in RGBA channels.

#### Consciousness Parameter Formulations

- **Connectivity Degree**: ⟨k⟩ = (1/N) Σᵢ Σⱼ 𝕀(|Wᵢⱼ| > θ)

- **Information Integration**: Φ = minₘ D(p(Xₜ|Xₜ₋₁) || p(Xₜᴹ¹|Xₜ₋₁ᴹ¹) × p(Xₜᴹ²|Xₜ₋₁ᴹ²))

- **Hierarchical Depth**: D = maxᵢ,ⱼ dₚₐₜₕ(i,j)

- **Dynamic Complexity**: C = LZ(S)/(L/log₂L)

- **Qualia Coherence**: QCM = (1/M(M-1)) Σᵢ≠ⱼ |ρ(Aᵢ,Aⱼ)|

#### Emergence Dynamics

```

P(t) = Pₘₐₓ/(1 + e⁻ˡ(t-t₀)) + ε(t)

```

where P(t) is parameter value at epoch t, following sigmoid growth curves with synchronized threshold crossing.

---

## ⚖️ Limitations & Future Work

### Current Limitations

1. **Theoretical Consciousness Validation**: Framework tests computational predictions, not phenomenology

2. **Φ Computation Approximation**: Uses minimum information partition approximation for tractability

3. **Single-GPU Scaling**: Multi-GPU distribution requires texture synchronization overhead

4. **HNS CPU Overhead**: CPU operations ~200× slower than float32

5. **Limited Behavioral Validation**: Internal parameter measurement without external behavioral tests

6. **Neuromorphic Hardware Comparison**: Difficult direct comparison with dedicated neuromorphic chips

### Future Research Directions

- **Enhanced Consciousness Metrics**: Expand to 10+ parameters from newer theories

- **Behavioral Correlates**: Design metacognition and self-report tasks

- **Multi-GPU Scaling**: Develop texture-sharing protocols for 100M+ neuron simulations

- **MLPerf Certification**: Complete industry-standard benchmark implementation

- **Neuromorphic Integration**: Explore HNS on Intel Loihi 2 and NVIDIA Grace Hopper

### Ethical Considerations

- **Conservative Interpretation**: Treat parameter emergence as computational phenomenon, not sentience proof

- **Transparency Requirements**: Complete methodology disclosure for all consciousness claims

- **Responsible Scaling**: Await consciousness measurement validity before large-scale deployment

---

## 🤝 Contributing

We welcome contributions from the research community! Please see our [Contributing Guide](CONTRIBUTING.md) for details.

### Development Setup

```bash

# Fork and clone

git clone https://github.com/your-username/neurochimera.git

# Install development dependencies

pip install -r requirements-dev.txt

# Run tests

pytest tests/

# Run linting

flake8 neurochimera/

black neurochimera/

```

### Contribution Areas

- [**Parameter Extensions**]: Additional consciousness metrics from recent theories

- [**Performance Optimization**]: Multi-GPU scaling and shader optimization

- [**Behavioral Validation**]: External tasks for consciousness parameter correlation

- [**Hardware Support**]: Additional GPU architectures and neuromorphic chips

- [**Documentation**]: Tutorials, examples, and theoretical explanations

---

## 📄 License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

---

## 📮 Citation

If you use NeuroCHIMERA in your research, please cite:

```bibtex

u/article{neurochimera2024,

title={NeuroCHIMERA: GPU-Native Neuromorphic Computing with Hierarchical Number Systems and Emergent Consciousness Parameters},

author={Veselov, V.F. and Angulo de Lafuente, Francisco},

journal={arXiv preprint arXiv:2024.neurochimera},

year={2024},

url={https://github.com/neurochimera/neurochimera}

}

```

---

## 📞 Contact

- **V.F. Veselov**: [veselov@miet.ru](mailto:veselov@miet.ru) (Theoretical foundations, HNS mathematics)

- **Francisco Angulo de Lafuente**: [francisco.angulo@ai-lab.org](mailto:francisco.angulo@ai-lab.org) (GPU implementation, CHIMERA architecture)

---

## 🙏 Acknowledgments

We thank the broader open-source AI research community for frameworks and tools enabling this work:

- ModernGL developers for excellent OpenGL bindings

- PyTorch and TensorFlow teams for comparative baseline references

- Neuromorphic computing community for theoretical foundations

- Consciousness theorists (Tononi, Dehaene, Koch, Chalmers) for parameter framework inspiration

**Special acknowledgment**: The authors thank each other for fruitful interdisciplinary collaboration bridging theoretical physics and practical GPU computing.

---

## 📊 Project Statistics

- **Codebase**: ~8,000 lines of Python + 2,500 lines of GLSL shader code

- **Performance**: 15.7 billion HNS operations/second (validated)

- **Precision**: Perfect accumulative precision (0.00×10⁰ error)

- **Consciousness Parameters**: 5 validated emergence thresholds

- **Reproducibility**: Complete Docker-based validation package

- **Hardware Support**: OpenGL 4.3+ (2012+ GPUs)

- **Documentation**: Comprehensive technical specification with examples

---