Keep the Brian2 modelling interface. Partition a supported neural network across processes with MPI, the communication layer behind Atlas distributed simulation.
Start with the local distributed example and explore the published multi-node results. A shared execution architecture also supports CPU, GPU, browser simulation and native training.
Brian2 Atlas adds distributed execution for supported Brian2 models. It assigns parts of one network to MPI processes, called ranks, and exchanges events between them as the simulation advances.
01 · The question
Does Brian2 support distributed simulation?
Upstream Brian2 does not natively split a single network simulation across machines with MPI. Its documented multiprocessing workflow runs independent simulations in parallel. Atlas adds a separate execution backend for partitioning a supported network.
02 · The distinction
Parameter sweeps and network partitioning
A parameter sweep runs separate networks or trials, each with its own state. Distributed network simulation divides work within one connected network and coordinates spike delivery and state updates across ranks.
03 · The implementation
Distributed simulation using MPI
MPI provides communication between ranks on one host or across nodes. Atlas supplies the model representation, ownership plan and event exchange. Model features, memory layout and cluster configuration determine which path is suitable.
Background: Brian2 parallel computation. The v0.1.0 MPI validation record covers same-host 1, 2 and 4 ranks; it does not qualify cross-host execution. The four-node research result below uses the manuscript's documented source snapshot and reproduction materials.
The architecture
Describe the model. Make execution explicit.
AtlasIR connects the equations you write to how a runtime schedules work, stores state and exchanges events. It makes those choices available for inspection and validation.
01
A familiar modelling interface
Define neurons, synapses, clocks and monitors with Brian2. Atlas adds its own execution backends while retaining the upstream modelling frontend.
02
A shared model contract
Represent typed state, scheduling, effects and event identities explicitly. Validate the representation before applying execution-plan transformations.
03
Simulation and native training
Alongside simulation, a bounded training extension provides forward and reverse execution plans with surrogate spike gradients.
CPUReference & AOT
Run with the reference engine or compile a model-specialized native executable.
GPUApple Metal & NVIDIA CUDA
Execute supported models on Apple or NVIDIA GPUs with float32 numeric mode.
BrowserWebAssembly
Export a supported model bundle for execution in a browser worker.
DistributedMPI
Partition supported networks across ranks, with explicit ownership and event exchange.
Choose a backend for the model features and hardware you need. The backend guide documents setup and support for each path.
From the arXiv manuscript
Measured on real workloads.
Three studies illustrate execution speed, preparation memory and distributed capacity. Each links to its methods and measurement scope.
CPU execution5.43×
Best-measured time ratio
0.839 s for Rust at 16 threads versus 4.555 s for Brian2 C++ at 8 threads, on the same Linux host.
Full-connectome simulation + recording. Reported medians; both backends constrained to 16 physical cores on one socket.Section 5.3 · Figure 4 Laptop capacity298.9M
Synapses on a 16 GB laptop
The PD14 workload completed 10 seconds of model time for 77,169 neurons on an Apple M3 laptop.
Recording disabled. The compared C++ preparation exceeded its controlled memory budget; this is a capacity result.Section 5.3 · Resource test Distributed capacity24.1B
Recurrent synapses across four nodes
A 4.13-million-neuron multi-area model completed 100.5 seconds of model time using 32 MPI ranks.
A research capacity configuration with its own source snapshot, output checks and resource records. This is separate from the public v0.1.0 same-host qualification.Section 5.2 · Figure 3
Install the tagged source release, select the reference CPU engine, and run a single neuron. Atlas runs on your own machine without a Next Brain account.
1. Install the source release
For a Unix-like shell, with Python 3.12+, Rust/rustup and a working C/C++ compiler available. The source install builds the native simulation and training executables.
Use the source repository's CUBA example to run one excitatory/inhibitory network at 1, 2 and 4 ranks on a single machine. It compares each run with an independent Rust float64 reference.
1. Prepare and launch
Complete the source installation above and install an MPI implementation with mpicc and mpiexec on your PATH. Run these commands from the repository root with the Python environment activated. Choose a new output directory for each invocation.
Distributed simulation commands
# From the v0.1.0 repository root, after source installation.
# Requires Rust 1.98.1 and MPI providing mpicc and mpiexec.
cargo +1.98.1 build --release --locked \
--manifest-path brian2-rust/Cargo.toml --bin b2-runner
# Launch this Python driver once; it starts the MPI workers.
python brian2-rust/examples/mpi_cuba.py \
--output output/distributed-cuba-first \
--neurons 100 --steps 256 --degree 8 --ranks 1 2 4
The example creates 100 neurons and 800 directed connections, then simulates 256 steps at 0.1 ms per step. The Python driver generates and compiles each MPI project and launches its workers; run the driver once, without wrapping it in mpiexec.
Open output/distributed-cuba-first/report.json. Each entry in runs should have exact_reference_match: true. The script compares SHA-256 hashes of results.bin and events.bin, records compilation and execution times, and raises an error on a mismatch.
3. Understand the scope
This is a same-host correctness example with replicated input arrays. It does not demonstrate distributed-memory scaling or a speedup. For multi-machine research, follow the manuscript's source versions and reproduction records, then validate your model and cluster configuration.
Brian2 Atlas is the engine you can install and develop with. Next Brain brings supported Atlas models into an online workflow for exploration, simulation and training.
Start with the illustrated overview, read the full manuscript, or inspect the source. The reproduction materials preserve the versions and configurations behind the published experiments.
Use this citation for the arXiv manuscript. For software, use the repository's citation metadata and record the exact commit used. The repository also preserves the upstream Brian2 citation.
Manuscript BibTeX
@misc{li2026atlas,
author = {Li, Xinjun},
title = {A Unified Intermediate Representation and Execution Architecture for Heterogeneous and Distributed Neural Simulation},
year = {2026},
eprint = {2610.23964},
archivePrefix = {arXiv},
primaryClass = {cs.CE},
doi = {10.48550/arXiv.2610.23964},
url = {https://arxiv.org/abs/2610.23964}
}
A few useful details.
How does Atlas relate to Brian2?
Atlas retains Brian2's modelling interface, upstream history and attribution, and adds its own execution architecture. It is developed by Next Brain. The repository scope explains the relationship and licensing.
What is open source, and under which licence?
Original Atlas engine code uses Apache-2.0. Retained Brian2 code remains under CeCILL 2.1. The manuscript and slides use CC BY 4.0. See the licence scope for the combined checkout.
Where should I start with GPU or distributed execution?
Start with the CPU example, then follow the backend guide for your model and hardware. GPU paths require their platform toolchains; MPI requires an MPI installation and a supported model. Browser execution uses a separate bundle-export API.
How can I contribute or reproduce a result?
Use GitHub issues for questions, bugs and proposed changes. The preprint repository contains the historical experiments and reproduction materials tied to the paper's source versions.
Develop in the open
Bring your next model.
Explore the source, reproduce an experiment, or help improve the engine.