Neuro, a compiled language for AI that matches Clang -O2

Neuro, an alpha-stage Ahead-of-Time compiled language for AI workloads, now compiles its full general-purpose language surface through an LLVM 20 backend, with planned MLIR-based tensor operations, Enzyme-based automatic differentiation, and GPU acceleration via MLIR dialects. The project's Phase 1 core language is complete, and Phase 2 (Tensors and MLIR) is open, with the language aiming to match Clang -O2 performance for high-performance AI development.

An AOT-compiled language for high-performance AI development. Status: Alpha. Phase 1 Core Language is complete: the full general-purpose language surface compiles and runs. Phase 2 Tensors and MLIR is now open. Per-phase status lives in one place: the Quick Roadmap quick-roadmap . Neuro is an Ahead-of-Time AOT compiled language for AI workloads. Python is interpreted and leans on C libraries for anything fast; Neuro compiles to native code through an LLVM 20 backend instead. Planned on top of that backend: - MLIR-based tensor operations, for static shape-verified tensor types - IR-level automatic differentiation via Enzyme - GPU acceleration via MLIR GPU dialects nvgpu, rocdl, Triton A single perceptron with ReLU activation; uses structs, impl blocks, associated functions, instance methods, if-expressions, implicit returns, and println . This file compiles and runs today. /PanzerPeter/Neuro/blob/main/examples/structs/neuron.nr struct Neuron { weight: f64, bias: f64 } impl Neuron { func new weight: f64, bias: f64 - Neuron { Neuron { weight: weight, bias: bias } } // ReLU activation: pass-through if positive, clamp to zero otherwise func activate &self, input: f64 - f64 { val z = input self.weight + self.bias if z 0.0 { z } else { 0.0 } } func is active &self, input: f64 - bool { val z = input self.weight + self.bias z 0.0 } } func main - i32 { val neuron = Neuron::new 0.5, -0.1 val dead = neuron.activate 0.0 // 0.0 0.5 − 0.1 = −0.1 → clamped to 0.0 val dead fires = neuron.is active 0.0 println "input 0.0 - {dead:.2} fires: {dead fires}" val active = neuron.activate 1.0 // 1.0 0.5 − 0.1 = 0.4 → passes through val active fires = neuron.is active 1.0 println "input 1.0 - {active:.2} fires: {active fires}" if dead 0.0 { return 1 } return active 10.0 as i32 // 4 } php input 0.0 - 0.00 fires: false input 1.0 - 0.40 fires: true Every row below is implemented, tested, and usable today. Depth lives elsewhere: the documentation site https://neuro-lang.netlify.app/ and docs/ /PanzerPeter/Neuro/blob/main/docs for reference material, CHANGELOG.md /PanzerPeter/Neuro/blob/main/CHANGELOG.md for the per-release detail, and the Quick Roadmap quick-roadmap for what is still ahead. | Feature | Summary | |---|---| | Types & inference | i8 through u64 , f16 / bf16 / f32 / f64 , bool , char , string ; literal suffixes, digit separators, as casts, type aliases, .is nan | | Functions & control flow | Recursion, forward refs, implicit returns, named arguments with external labels clamp x, min: 0.0 ; if / elif / else , while , loop , range- for , for i, x in xs.enumerate , labelled break / continue , block-as-value; for over any type implementing the prelude's IntoIterator / Iterator protocol, plus .map f / .filter p head adapters | | Generics | Generic functions, structs, and impls plus const generics, where clauses, and turbofish, all fully monomorphized at zero runtime cost | | Traits & dispatch | Required and default methods, associated types type Item / Self::Item and Trait<Assoc = T bounds, operator traits, impl Trait static and dyn Trait vtable dispatch with object-safety checks | | Closures & lambdas | \|x: i32\| x x , move closures, T - R function types, higher-order functions; compiled to { fn ptr, env ptr } , no heap | | Structs & methods | Fields, shorthand init, functional update ..base , impl blocks with &self / &mut self methods and associated functions; @derive Copy, Clone, Debug, PartialEq for copying, {p:?} rendering, and structural equality | | Enums & newtypes | Unit, tuple, and struct-field variants; generic enums monomorphized per type argument; newtype for distinct nominal wrappers | | Arrays, tuples & collections | Fixed-size T; N and anonymous tuples over Copy elements; borrowed slices & T / &mut T with zero-copy .slice range over an array or a Vec ; heap-backed Vec<T , HashMap<K, V , BTreeMap<K, V , String that move on assignment and free at scope exit; statically shaped Tensor<T, d0, ... built from an annotated nested literal or Tensor::<T, ... ::zeros / ones / identity / random normal / scalar / from , owning its buffer with .clone , .to device , and in-place += / -= / = / /= / %= | | Pattern matching | Exhaustive match expressions over variant / literal / or / range / wildcard patterns with if guards, plus val Point { x, y } = p and val a, ..rest = arr destructuring | | Option / Result | Option<T and Result<T, E from the implicit prelude. They are ordinary generic enums, available with no declaration and no import, variants included; ?? unwraps either with a lazy fallback; ? propagates the failure to the caller; val-else unwraps or exits the scope; checked add / checked sub / checked mul report integer overflow as Option::None | | Ownership & borrows | Move-by-default, Copy , deterministic Drop , &T / &mut T with flow-sensitive exclusivity, lifetime elision and annotations | | Strings | Immutable fat-pointer string with escapes, &string slices, == , + concatenation, .len / .clone / .slice a..b / .char slice a..b , codepoint iteration with .chars and .char indices , interpolation "{x:.2}" , triple-quoted """ blocks with dedent; growable String buffer for building text: push str / clear / to string | | Modules & visibility | Multi-file programs: every .nr file is a module and mod.nr directories nest; inline module { } blocks group within one file; import math::{sqrt} , import ./utils , as renames, module aliases, variant imports, and export import re-export facades; declarations and struct fields are private until export opts them in; an implicit prelude puts Option / Result and Some / None / Ok / Err in every module, with @no prelude to opt out | | Toolchain | Native binaries via inkwell 0.10 / LLVM 20; neurc check and neurc compile ; buffered print / println to stdout, line-buffered on a terminal and drained on every exit path; panic / assert / unreachable runtime with located diagnostics, covering array bounds, string slices, a zero divisor, and debug-build integer overflow, all outlined off the hot path | Alpha memory warning. Stack values are reclaimed on return and string literals live in .rodata , so neither leaks. Move semantics, borrows, deterministic Drop , and the owning collections have landed, so a Vec , HashMap , BTreeMap , or String frees its buffer at scope exit. A heap string the one + concatenation and interpolation produce is freed too when the compiler can prove who owns it: a temporary the statement consumes, or a binding whose initializer allocated it. A loop that formats output therefore holds steady rather than growing. What still leaks is a heap string that escapes what the compiler can follow: one stored into a collection or a struct field, one returned from a function, and the prior value of a reassigned binding. The ownership test answers conservatively by design, since freeing a .rodata literal would be far worse than holding a buffer. This block is removed once those results are tracked too. Until then, do not assume memory-safety semantics beyond what the table above claims. If memory-safety semantics and compiler backend design are your thing, this is exactly where contributors are needed /PanzerPeter/Neuro/blob/main/CONTRIBUTING.md . neurc compile -O 3 hands the module to the same LLVM 20 optimization pipeline clang -O2 uses, so compute-bound code lands in the same range as C++ rather than somewhere between C++ and Python. Best of nine runs on one machine, lower is better. Reproduce with python benchmarks/run.py , which builds all three implementations of each program and refuses to report timings if they disagree on output: | Benchmark | What it stresses | Neuro -O 3 | clang -O2 | Python 3.14 | |---|---|---|---|---| | mandelbrot | scalar f64 in a tight loop | 166 ms | 166 ms | 5791 ms | | vector sum | Vec push, indexed sweep | 25 ms | 26 ms | 10068 ms | | call overhead | recursion, call and inline cost | 45 ms | 51 ms | 1389 ms | | print lines | integer holes to standard output | 13 ms | 22 ms | 110 ms | | format floats | f64 holes at a fixed precision | 118 ms | 109 ms | 214 ms | | int divide | guarded / and % , opaque divisor | 96 ms | 89 ms | 1318 ms | Absolute times belong to the machine rather than to the language, and the Python column to whichever python3 is on your PATH, which is why the version is named. Two rows are worth a word. print lines beats C because an integer hole renders through a digit loop instead of snprintf ; int divide is the one place the compiler spends rather than saves, since / and % guard the operand pairs the hardware instruction leaves undefined and an opaque divisor keeps those guards in the loop. The default is -O 0 : checked arithmetic, no optimization pipeline. Pass -O 3 before drawing any conclusion about speed. | Requirement | Version | Notes | |---|---|---| | Rust | 1.85+ | Install via rustup https://rustup.rs/ | | LLVM 20 | 20.x with dev libs | Platform instructions below | | C linker | any | gcc / clang on Linux/macOS; MSVC on Windows | This is the only step that differs between systems. Add the export to your shell profile ~/.bashrc , ~/.zshrc so it survives a new terminal. Arch Linux / CachyOS sudo pacman -S llvm20 export LLVM SYS 201 PREFIX=/usr/lib/llvm20 Ubuntu / Debian wget -qO- https://apt.llvm.org/llvm.sh | sudo bash -s -- 20 or the full dev package set: sudo apt-get install llvm-20 llvm-20-dev llvm-20-tools libpolly-20-dev export LLVM SYS 201 PREFIX=/usr/lib/llvm-20 macOS Homebrew brew install llvm@20 export LLVM SYS 201 PREFIX="$ brew --prefix llvm@20 " Windows 10 / 11 x64 needs a longer walkthrough; see below. With LLVM in place and Rust installed from rustup.rs https://rustup.rs/ : git clone https://github.com/PanzerPeter/Neuro.git cd Neuro cargo build --release cargo test --workspace cargo install --path compiler/neurc optional, puts neurc on your PATH On Windows the same four commands run unchanged in PowerShell, and cargo install places neurc.exe in %USERPROFILE%\.cargo\bin , which rustup has already added to PATH . Windows needs the MSVC toolchain, not GNU, and LLVM does not come from a package manager. Four extra steps, after which Step 2 above runs unchanged. Install Visual Studio Build Tools. Download from visualstudio.microsoft.com/downloads https://visualstudio.microsoft.com/downloads/ under Tools for Visual Studio → Build Tools for Visual Studio 2022 , and select the Desktop development with C++ workload. 2019 or later works. Install Rust. Run rustup-init.exe from rustup.rs https://rustup.rs/ and choose 1 Proceed with standard installation , which selects the stable-x86 64-pc-windows-msvc toolchain. Open a new PowerShell window afterwards so cargo and rustc are on PATH . Install LLVM 20 to a path without spaces the NSIS installer enforces this : php $version = "20.1.8" $url = "https://github.com/llvm/llvm-project/releases/download/llvmorg-$version/LLVM-$version-win64.exe" curl.exe -fsSL -o "$env:TEMP\llvm-installer.exe" $url Start-Process "$env:TEMP\llvm-installer.exe" -ArgumentList "/S /D=C:\LLVM" -Wait -PassThru | Out-Null The installer is also downloadable by hand from the LLVM releases page https://github.com/llvm/llvm-project/releases . Point the build at it. No admin rights needed: Environment ::SetEnvironmentVariable "LLVM SYS 201 PREFIX", "C:\LLVM", EnvironmentVariableTarget ::User $current = Environment ::GetEnvironmentVariable "Path", "User" Environment ::SetEnvironmentVariable "Path", "$current;C:\LLVM\bin", "User" Close and reopen PowerShell, then check with llvm-config --version , which should print 20.x.y . Troubleshooting Windows build errors llvm-sys build script cannot find LLVM : confirm LLVM SYS 201 PREFIX is set in the current shell session echo $env:LLVM SYS 201 PREFIX and points to a directory that contains bin\llvm-config.exe . link.exe not found : the MSVC Build Tools are not on PATH . Run the build from a Developer PowerShell / x64 Native Tools Command Prompt or install the C++ build tools workload as described above. Version mismatch llvm-sys-201 requires LLVM 20 : an older LLVM is on PATH . Set LLVM SYS 201 PREFIX explicitly to the LLVM 20 prefix and ensure C:\LLVM\bin precedes any other LLVM entries in PATH . Type-check a source file no binary produced cargo run -p neurc -- check examples/basics/hello.nr Compile to a native executable cargo run -p neurc -- compile examples/basics/factorial.nr Run the compiled binary emitted next to the source file ./examples/basics/factorial After cargo install --path compiler/neurc: neurc compile examples/basics/factorial.nr // Immutable by default val x: i32 = 42 val name: string = "Neuro" // Mutable with reassignment mut counter: i32 = 0 counter = counter + 1 // Type inference works for both val and mut val pi = 3.14159 // inferred f64 val n = 100 // inferred i32 mut count = 0 // inferred i32; type annotation optional php // Explicit return func add a: i32, b: i32 - i32 { return a + b } // Expression-based implicit return trailing expression func multiply a: i32, b: i32 - i32 { a b } php func fizzbuzz n: i32 - i32 { mut i: i32 = 1 while i <= n { i = i + 1 } i } func sum n: i32 - i32 { mut total: i32 = 0 for i in 0..n { total = total + i } total } php struct Point { x: f64, y: f64 } func distance p: Point - f64 { // field read val dx = p.x val dy = p.y dx dx + dy dy // placeholder no sqrt yet } func main - i32 { val origin = Point { x: 0.0, y: 0.0 } // field mutation requires mut binding mut cursor = Point { x: 3.0, y: 4.0 } cursor.x = 1.0 return 0 } Verbatim from examples/showcase/closures.nr /PanzerPeter/Neuro/blob/main/examples/showcase/closures.nr . It compiles, links, prints the three results below, and exits with code 90. // Apply f to each element of a 4-element array and sum the results. func map sum xs: i32; 4 , f: i32 - i32 - i32 { mut total: i32 = 0 mut i: i32 = 0 while i < 4 { total += f xs i i += 1 } return total } struct Scaler { factor: i32 } impl Scaler { func apply &self, x: i32 - i32 { x self.factor } } func main - i32 { val data: i32; 4 = 1, 2, 3, 4 // A closure capturing a Copy local bias by value. val bias = 10 val biased = map sum data, |x: i32| x + bias // 11+12+13+14 = 50 // A move closure with a block body and early return. val scale = 3 val scaled = map sum data, move |x: i32| - i32 { val y = x scale return y } // 3+6+9+12 = 30 // A struct method still resolves alongside closures. val s = Scaler { factor: 2 } val doubled = s.apply 5 // 10 println "capture by value |x| x + bias = {biased}" println "move closure move |x| x scale = {scaled}" println "struct method s.apply 5 = {doubled}" val total = biased + scaled + doubled println "total = {total}" total // 50 + 30 + 10 = 90 } Every runnable program in examples/showcase/ /PanzerPeter/Neuro/blob/main/examples/showcase combines several features at once and is pinned twice: to an expected exit code in examples/expected.txt /PanzerPeter/Neuro/blob/main/examples/expected.txt , and to the exact text it prints in a sibling .out file. By-value tensor arithmetic, @grad , and GPU kernels are not shown here because they do not exist yet; tensor construction does, in showcase/model shapes.nr /PanzerPeter/Neuro/blob/main/examples/showcase/model shapes.nr , and the in-place update in showcase/optimizer step.nr /PanzerPeter/Neuro/blob/main/examples/showcase/optimizer step.nr . See the Quick Roadmap quick-roadmap . Neuro follows Vertical Slice Architecture VSA : the code is organized by language feature, not by technical layer. compiler/ ├── infrastructure/ Shared, zero-business-logic crates │ ├── ast-types/ AST node definitions │ ├── diagnostics/ Error / warning types + rendering │ ├── project-config/ Project / manifest configuration │ ├── shared-types/ Primitives shared across slices │ ├── source-location/ Spans, positions, source files │ └── neuro-hir/ Typed High-Level IR frontend ↔ backend contract ├── lexical-analysis/ Tokenizer logos, Unicode XID ├── syntax-parsing/ Pratt + statement parser → AST ├── semantic-analysis/ Type checker, scope analysis ├── control-flow/ CFG data structures; no caller yet ├── hir-lowering/ Type-checked AST → typed HIR ├── llvm-backend/ HIR → object code inkwell 0.10 / LLVM 20 ├── mlir-backend/ HIR → MLIR scaffold off-by-default mlir feature └── neurc/ CLI compiler driver pipeline orchestration Today: Source .nr → Lexical Analysis tokens → Syntax Parsing AST → Semantic Analysis type-checked AST → HIR Lowering typed High-Level IR, neuro-hir → LLVM Backend object code via inkwell / LLVM 20 → System Linker native executable Planned extension Phase 2+ : Tensor/AI path: typed High-Level IR neuro-hir → MLIR linalg/tensor/func/arith, LLVM 20 / MLIR 20 → Enzyme MLIR AD pass @grad → GPU dialects nvgpu/rocdl/Triton or llvm dialect → inkwell → native code Each numbered phase is a MAJOR-version milestone: completing Phase N ships v N+1 .0.0 . Phase 1 is complete and we are now in Phase 2 . A phase is divided into lettered sub-phases. | Phase | Goal | Status | |---|---|---| | 1 | Core Language : types, control flow, LLVM backend, ownership and borrow checking, generics, traits and dispatch, closures, enums and pattern matching, error handling, modules and prelude, string interpolation | Complete | | 2 | Tensors and MLIR : first-class tensor types lowered through MLIR Linalg, plus the pool allocator. Finishing it ships v3.0.0 | In progress | | 2A | Standard I/O and spec stragglers: print / println , .is nan , codepoint string APIs, .enumerate , borrowed slices & T , the iterator protocol, @derive Debug, PartialEq | Complete | | 2B | Tensor core: Tensor<T, ... , literal coercion, move semantics, DLPack, slicing, shape generics, named dims, dynamic shapes, reductions | In progress | | 2C | MLIR lowering: tensor arithmetic to Linalg, broadcasting, matmul behind @ , end-to-end HIR → MLIR → LLVM | Planned | | 2D | Pool allocator: pool blocks, PoolAware , LIFO release at scope exit | Planned | | 2E | Functional sugar: pipeline \| , composition , einstein notation, functional tensor ops | Planned | | 3 | Automatic differentiation: Enzyme MLIR pass, @grad wrt: ... , .backward / .zero grad , higher-order derivatives, SGD | Planned | | 4 | GPU acceleration: MLIR GPU dialects nvgpu / rocdl / Triton , @gpu , KernelOut<T aliasing model, device memory pool, CPU fallback | Planned | | 5 | Neural network standard library: TrainableTensor , ParameterList , optimizers, @model , Dense / Conv2d / Attention, .nrm serialization | Planned | | 6 | Async runtime: async func , Future<T , spawn , JoinHandle , join / race , executor for data-loader / I/O overlap | Planned | | 7 | Interop and advanced features: Python FFI via DLPack, spread operator, advanced pattern matching, custom attributes, defer | Planned | | 8 | Developer experience: Language Server Protocol, diagnostics polish, formatter, @test runner | Planned | | 9 | Package manager and distribution: neurpm , cross-OS installer / uninstaller / self-updater, signed release binaries, optimization passes loop unrolling, AD-aware inlining, LTO | Planned | Set LLVM SYS 201 PREFIX for your platform before running any Cargo command see Installation installation for the correct path per OS . Build the full workspace cargo build --workspace Run all tests cargo test --workspace Lint cargo clippy --workspace --all-targets -- -D warnings Format check cargo fmt --all -- --check Apply formatting cargo fmt --all On Windows, use PowerShell or a Developer Command Prompt. The env var must be set in the current session; prefix it inline if needed: $env:LLVM SYS 201 PREFIX = "C:\LLVM" cargo build --workspace Syntax highlighting for .nr files is included in neuro-language-support/ . cd neuro-language-support npm install -g @vscode/vsce once vsce package - neuro-language-support-<version .vsix code --install-extension neuro-language-support- .vsix --force Reload the VS Code window afterwards Developer: Reload Window . A grammar change does not apply to already-open editors. During grammar work, symlinking the folder into ~/.vscode/extensions/ avoids repackaging: a window reload then picks up every edit. | Extension | Purpose | |---|---| | .nr | Neuro source files | | .nrl | Compiled library modules | | .nrm | Serialized model/matrix data | | .nrp | Package definitions | See CONTRIBUTING.md /PanzerPeter/Neuro/blob/main/CONTRIBUTING.md for architecture guidelines, coding standards, and the pull request process. Confirmed open defects live in docs/BUGS.md /PanzerPeter/Neuro/blob/main/docs/BUGS.md . Fixing one is the best way to start. The project is in early alpha, so breaking changes are expected. Contributions should focus on Phase 2 Tensors and MLIR ; the Quick Roadmap quick-roadmap marks which phase is currently open. AI development is stuck in a fragmented paradigm: developers iterate in an interpreted glue language Python , while underlying libraries are written in unmanaged, safety-critical systems languages C++/CUDA . Neuro is built to unify this stack: 1. True native performance. Compiled AOT via LLVM 20, with no heavy runtime interpreter and no global interpreter lock GIL . Measured against C++ and Python performance on compute-bound programs. 2. AI-First Type System: Native compile-time shape verification for tensors using MLIR Phase 2 , preventing runtime dimension mismatches before a single line of training executes. 3. Immutability by Default: A modern val / mut paradigm to ensure highly parallelized tensor computations are thread-safe by design. Licensed under the Neuro Shared Source License v2.1 /PanzerPeter/Neuro/blob/main/LICENSE . Why not MIT/Apache 2.0 right now? Neuro is in a critical pre-stabilization phase. The license protects against three specific risks: commercial re-packaging of the compiler before the language spec is stable, AI-assisted reproduction of the compiler for a competing product, and misleading forks that fragment the early ecosystem. None of these restrictions affect normal use. What you can do freely: - Use, study, and modify the compiler for any personal or internal purpose - Write Neuro programs and distribute or sell the compiled output under any terms you choose. programs you compile are wholly exempt from this license - Build tools, plugins, and editor integrations that call into the compiler - Contribute code back to the project What requires a commercial license: - Redistributing the Neuro compiler itself or a fork of it as part of a commercial product See LICENSE /PanzerPeter/Neuro/blob/main/LICENSE for full terms. Inspired by Rust ownership, type system , Python AI ecosystem simplicity , Swift language ergonomics , and Mojo AI-first design . Built with inkwell https://github.com/TheDan64/inkwell , logos https://github.com/maciejhirsz/logos , and the LLVM https://llvm.org/ infrastructure.