# Neuraxon 2.0 runs a trinary neural unit in continuous time

> Neuraxon is a bio-inspired neural network written in pure Python with no external dependencies, where units take excitatory, neutral or inhibitory states, synapses carry three weights and can be rewired, and a four-step plasticity pipeline runs every simulation step. It is a research blueprint rather than a library with a stable API, and the version numbers in the repository reflect that.

**DavidVivancos/Neuraxon** — Neuraxon Paper With Code

- Repository: https://github.com/DavidVivancos/Neuraxon
- Stars: 536 · Forks: 19
- Language: Python
- License: NOASSERTION
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/davidvivancos-neuraxon

## A computational unit, not a layer in a framework

Neuraxon is described as a bio-inspired computational unit that goes beyond the classic perceptron, and the design choices are specific rather than metaphorical. Logic is trinary, with +1 excitatory, 0 neutral and -1 inhibitory, so a unit carries three states rather than two. Time is continuous, with inputs flowing as constant streams rather than arriving in discrete ticks. Computation happens at both the neuron and the synapse level, which is the part that separates this from a conventional recurrent layer. Synapses hold three dynamic weights named w_fast, w_slow and w_meta, and they can form, collapse or reconnect, so the topology changes during the run. Hidden neurons can die. The result is a network whose structure is a function of its own history, and the README argues that traditional networks and even most spiking networks do not have that property.

## The four-step pipeline that runs every step

Version 2.0 is organised around a unified pipeline executed on every simulation step, and this is the core of the design. Step one is Time Warping, labelled ChronoPlasticity, which gives each synapse an adaptive memory horizon. Step two is Dynamic Decay, or DSN, an input-conditioned decay computed through causal convolution, so a synapse's forgetting depends on what is arriving. Step three is the CTSN complemented state, a learnable complement term that the README says prevents information loss. Step four is AGMP, Astrocyte-Gated Multi-timescale Plasticity, computed as eligibility times modulator times an astrocyte gate. On top of that sit four coordinated regulatory loops in MSTH, Multi-Scale Temporal Homeostasis, running from ultrafast to slow, a receptor system with nine subtypes and tonic and phasic modes, an oscillator bank with cross-frequency coupling, nonlinear dendritic branch integration with supralinear gamma, and Watts-Strogatz small-world topology built from a ring plus rewiring.

## No dependencies, and what that means in practice

The packaging is unusually simple, and the setup script is the whole story:

```python
    name="neuraxon",
    version="0.1.0",
    python_requires=">=3.7",
    install_requires=[],  # No external dependencies!
```

The requirements file says the same thing in two comment lines, that no external dependencies are required and that Neuraxon uses only the Python standard library. The package metadata lists development status as 3 - Alpha, with an intended audience of Science and Research, and classifies the licence as OSI Approved MIT License. Because there is nothing to install beyond the module itself, there is no version conflict with a project's existing PyTorch or NumPy stack, and the code can be read end to end without following a dependency graph. The trade is that any acceleration or parallelism is your problem, which is presumably why the CUDA kernels exist in a separate directory.

## The repository is a research workspace, not one package

The top level of the repository shows the scope. There is neuraxon.py for the first version and neuraxon2.py for the second, with a separate readme-Nxon1.md documenting the earlier design, and MultiNeuraxon2.py for the multi-sphere variant. The cuNxon/ directory holds the CUDA kernels and library, GameOfLife/ holds several generations of the Game of Life research code including a version 5.1 v196 and a live server and client under NxonLive, and NXAnt/ appears to be another component. There is a datasets.md, an examples/ directory whose entry point is basic_usage.py, a tests/ directory, a PDF of the first version paper and a THIRD_PARTY_LICENSES.md file. Two Hugging Face datasets are linked for the life simulation, a 1M set and a 100K time series set, and several Spaces host interactive demos including a 3D network builder and a multi-sphere builder that includes a fruit fly connectome preset. The last push was on 2026-10-13.

## The live server and the demos

The most immediately accessible thing in the project is not the library but the hosted demos. A Neuraxon Live server and client, version 1.065 v1085 from October 13th 2026, is playable online at nxon.online, and the repository tree includes an NxonKaleido brain visualization with it. There is a Game of Life 5.0 Lite demo on a Hugging Face Space described as based on Multi Neuraxon 2.0 with a first proto-language and audition feature, and a Game of Life 5.1 v196 research version based on Neuraxon 2.0 that introduces a first g factor and evolutionary neural architecture search. The interactive 3D network builder and the multi-sphere 3D builder are the demos for people who want to construct networks visually rather than in code. For evaluating whether this line of work is worth your time, running the hosted version costs nothing and tells you more than reading the description.

## What the project claims, and what has been measured

The README's framing of the problem is that traditional networks and even most spiking ones suffer from discrete time steps, binary or spiking simplification, static topologies, catastrophic forgetting and catastrophic rigidity, and that Neuraxon 2.0 addresses these at the architectural level. The listed outcomes are continuous real-time learning with no separate training and inference phases, temporal richness where timing and duration and frequency and sequence of trinary states encode information, biological plausibility in the form of dendrites and silent synapses and neuromodulation and spontaneous activity, energy efficiency through sparse trinary activity with multi-timescale decay, and evolvability through what the README calls Aigarth hybrid intelligent tissue for population-level mutation and selection. The applications named are embodied and robotic control with proprioception, real-time temporal pattern recognition, cognitive modelling of attention and sleep and wake cycles, continual lifelong learning, edge AI and neuromorphic hardware, and artificial life. What is not in the repository is a benchmark table, so these are the authors' claims and the preprint, not a set of numbers you can check.

## Where Neuraxon is the wrong choice

Three cases. The first is production: the package is marked alpha, the version in the setup script is 0.1.0, the repository publishes no GitHub releases, and the release line inside the Game of Life directory carries its own build numbers, which is what a research workspace looks like rather than a maintained library. The second is scale, because the pure Python core with continuous-time streams and per-step plasticity and structural rewiring is not what you would run in a serving loop, and the CUDA path in cuNxon is a separate piece of work with its own setup. The third is a team that needs peer-reviewed results, since the theoretical foundation is a preprint with a ResearchGate link and a promise of a later IEEE Xplore posting, and the repository has no evaluation harness to speak of beyond a tests/ directory. Against a mainstream framework such as a standard recurrent or spiking network, the difference in approach is that Neuraxon changes the unit and the topology as well as the activation function, which is why it can adapt without a training phase and also why there is no familiar layer API to drop into an existing model.

## Conclusion

Neuraxon is a good fit for a researcher who wants to experiment with continuous-time, structurally plastic neural dynamics and is happy to read the source to understand each mechanism, since the core implementation is a single pure Python module with no dependencies to install. It is a poor fit for production work, for a team that needs a stable API, and for anyone expecting the paper's claims to have been benchmarked, because the repository publishes no releases and the results live in a preprint. Check three things before you build on it: that the pure Python path is enough for your scale, since the CUDA kernels live in the separate cuNxon directory and would take a different setup, that you are on a supported Python version, since the setup script asks for 3.7 or newer and the classifier list runs from 3.7 through 3.15, and that the licence is what you expect, since the package metadata claims MIT while the repository itself is recorded as carrying a custom licence that GitHub cannot classify.

## FAQ

### What is Neuraxon and what makes its units different?

Neuraxon is a bio-inspired computational unit that uses trinary logic with +1 excitatory, 0 neutral and -1 inhibitory states, operates in continuous time with inputs flowing as constant streams, and computes at both neuron and synapse level. Synapses have three dynamic weights, w_fast, w_slow and w_meta, and can form, collapse or reconnect.

### Does Neuraxon need any Python packages installed?

No. The requirements file states that no external dependencies are required and that Neuraxon uses only the Python standard library, and the setup script has an empty install_requires list. The package requires Python 3.7 or newer.

### What are the four steps of the Neuraxon 2.0 pipeline?

Time Warping, called ChronoPlasticity, which gives an adaptive memory horizon per synapse; Dynamic Decay, or DSN, an input-conditioned decay via causal convolution; the CTSN complemented state, a learnable complement term intended to prevent information loss; and AGMP, Astrocyte-Gated Multi-timescale Plasticity, computed as eligibility times modulator times astrocyte gate.

### What is the CuNxon CUDA library in the Neuraxon repository?

It is a set of CUDA kernels and a library for Multi Neuraxon 2.0, held in the cuNxon directory of the repository alongside the pure Python core implementation neuraxon2.py. The core module is described as backward-compatible with v1 and free of external dependencies, with the CUDA path being a separate acceleration route.

### Can I try Neuraxon without installing it?

The repository links hosted demos, including a Neuraxon Live server and client playable online at nxon.online, a Game of Life 5.0 Lite demo on a Hugging Face Space, and interactive 3D network builder and multi-sphere builder Spaces. Two datasets are also linked on Hugging Face, a 1M set and a 100K time series set.

## Sources

- [DavidVivancos/Neuraxon on GitHub](https://github.com/DavidVivancos/Neuraxon)
- [Issues](https://github.com/DavidVivancos/Neuraxon/issues)
- [README](https://github.com/DavidVivancos/Neuraxon/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/davidvivancos-neuraxon