NEURON integrates automatic differentiation, temporal safety, causal do-calculus, and uncertainty tracking directly into the type system. No more silent bugs at 3 AM.
No more chasing silent numerical bugs, data leakage, or invalid causal claims through thousands of log lines.
Prevents lookahead bias at compile time. Variables carry temporal direction properties, and future data access is rejected by the type checker.
First-class do-calculus. Distinguishes observe() from intervene() to prevent correlation/causation errors at compile time.
Uncertain[Tensor] types propagate confidence bounds through operations. The compiler warns if you forget to check confidence.
Every function is differentiable. Tape-based reverse-mode AD with backward passes for MatMul, ReLU, Softmax, CrossEntropy, MSE, Sqrt, Sum, Mean.
Fused element-wise CUDA kernels compiled at runtime via NVRTC. Persistent VRAM architecture with dedicated allocation, caching pool, and zero-copy host-device tracking.
Side effects must be declared. [Effect[Mut[self], IO]] ensures pure forward passes are separated from training loops.
Selective unlearning built into the runtime. forget() uses Fisher Information Noise Scrubbing to scramble targeted task representations and issues a signed ForgetCertificate.
Compiles math kernels directly into native assembly or CUDA code at runtime. Sub-millisecond compilation scaling for deep networks, bypassing the interpreter.
Select an example, then click Compile & Run to see NEURON's compiler catch bugs.
A native compiler pipeline ensuring safety and extreme JIT execution performance.
Write .nr files with models, causal graphs, and tensor math
Indent-aware tokenization, recursive descent parsing
Shapes, temporal, causal, uncertainty, effect verification
SSA-style CFG with basic blocks and tape nodes
VM interpreter, JIT transpiler, and CUDA GPU kernels
How compile-time guarantees replace tedious debugging loops.
| Safety Check | PyTorch | JAX | NEURON |
|---|---|---|---|
| Tensor Shape Verification | ✗ Runtime Crash | ✗ JIT Compile-time | ✓ Static Compile-time |
| Temporal Leak Prevention | ✗ None (Silent Bug) | ✗ None (Silent Bug) | ✓ Static Type Error |
| Causal Intervention Checking | ✗ Manual tracking | ✗ Manual tracking | ✓ Static Type Error |
| Uncertainty Warnings | ✗ None | ✗ None | ✓ Compiler Warning |
| Gradient Computation | ✓ Library (Tape) | ✓ JIT Transform | ✓ Native Syntax |
| GPU Acceleration | ✓ CUDA | ✓ XLA | ✓ CUDA JIT (NVRTC) |
NEURON JIT delivers CPU execution speeds competitive with PyTorch, outperforming interpreted Python.
100 steps, batch size 64, Adam optimizer (lower is better)
Relative speedup vs. interpreted baseline (higher is better)
Cache-friendly memory access patterns in MatMul enabling CPU auto-vectorization into AVX2 instructions.
Caching allocator recycles intermediate vectors, eliminating dynamic allocation locks during backpropagation.
LLVM proves indexing limits, removing runtime safety check overhead in hot loops.
Moves exponentiation calculations outside element-wise optimization steps.
A library wrapper cannot verify mathematical properties at the syntax level. Shape errors, temporal lookahead bias, and causal mode confusion only manifest as runtime exceptions or silent numerical discrepancies in Python. By writing a custom compiler in Rust, NEURON validates the structure of your computation graph before execution.
NEURON implements temporal direction analysis during type verification. When you construct a Temporal[T, past_to_future] reference, the compiler tracks data flow direction. Any operation like .after(k) that references future timestamps flips the direction to future_to_past, which is then rejected if passed to a function expecting past-only data.
The compiler (neuronc) is written in Rust and runs on Windows, macOS, and Linux. The JIT compiler uses rustc to compile generated Rust code. GPU execution is supported on CUDA-capable NVIDIA GPUs using runtime compilation via the NVRTC library. Native code generation targets standard x86_64 AVX2 instruction sets.
The BSL allows 100% free use for development, testing, research, and non-production deployments. For proprietary commercial workloads, it requires a commercial license. This ensures sustainable funding while guaranteeing the code becomes fully open-source (Apache 2.0) on January 1, 2030.
The compiler, runtime, and standard library are fully functional. Start building today or reach out for enterprise partnerships.
The full compiler, JIT, interpreter, GPU backend, and standard library — free to use.
For commercial deployments, custom integrations, and dedicated engineering support.
NEURON balances unrestricted access for developers with sustainable funding for long-term development.
Clone the repo, run your first program, and experience compile-time safety for machine learning.
