Shapes in the types.Gradients in the compiler.

Neuro is a compiled language for machine learning. A mismatched matmul fails the build instead of the training run, @grad derives the backward pass before the program starts, and a @gpu function runs as an NVIDIA or AMD kernel.

Install neurc Read the docs

Alpha · phase 5 of 10 in progress · source on GitHub

The shape is part of the type.

Tensor<f32, [3, 2]> is a type, not a comment. x has three rows and two columns, w has two rows and one column, and the compiler knows both before anything runs.

func loss(
    x: &Tensor<f32, [3, 2]>,
    y: &Tensor<f32, [3, 1]>,
    w: &mut Tensor<f32, [2, 1]>
) -> Tensor<f32, []> {

func loss(
    x: &Tensor<f32, [3, 2]>,
    y: &Tensor<f32, [3, 1]>,
    w: &mut Tensor<f32, [2, 1]>
) -> Tensor<f32, []> {

A batch axis that changes at run time is written ?, as in Tensor<f32, [?, 4]>: that one axis opts out and every other axis is still checked. Dynamic shapes

`@` is checked where you write it.

[M, K] @ [K, N] gives [M, N], so x's columns must match w's rows. Here K is 2 on both sides: the product is a [3, 1] and - y lines up with it.

val r = x @ w - y    // [3, 2] @ [2, 1], checked

val r = x @ w - y    // [3, 2] @ [2, 1], checked

Change one number and the build stops.

Make w a [3, 1] and neurc check refuses the file. Not a crash ninety minutes into training: a located error, before a binary exists.

w: &mut Tensor<f32, [3, 1]>

w: &mut Tensor<f32, [3, 1]>

$ neurc check least_squares.nr

Type errors found in "least_squares.nr":
error: the operands of `@` do not multiply: &Tensor<f32, [3, 2]> against &mut Tensor<f32, [3, 1]>; matrix multiplication takes two rank-2 tensors whose inner axes agree, `[M, K] @ [K, N]` giving `[M, N]`
 --> least_squares.nr:8:13
  |
8 |     val r = x @ w - y
  |             ^^^^^

Error: 1 type error(s) found

The compiler writes the backward pass.

@grad(wrt: [w]) asks for the derivative of loss with respect to w. neurc generates it from typed IR while it compiles, so l.backward() calls a function that already exists. Nothing records a graph while the program trains.

Checked: every derivative rule against finite differences
Second order: order: 2 and .hessian() for curvature
Fenced: .detach() and @no_grad stop the gradient
Typed: the gradient has the parameter’s exact shape

least_squares.nr

// Least squares: find w so that x @ w = y.
@grad(wrt: [w])
func loss(
    x: &Tensor<f32, [3, 2]>,
    y: &Tensor<f32, [3, 1]>,
    w: &mut Tensor<f32, [2, 1]>
) -> Tensor<f32, []> {
    val r = x @ w - y    // [3, 2] @ [2, 1], checked
    Tensor::scalar((&r * &r).mean())
}

func main() -> i32 {
    val x: Tensor<f32, [3, 2]> =
        [[1.0, 2.0], [2.0, 0.0], [3.0, 1.0]]
    val y: Tensor<f32, [3, 1]> = [[5.0], [2.0], [5.0]]
    mut w: Tensor<f32, [2, 1]> = [[0.0], [0.0]]
    for _ in 0..200 {
        val l = loss(&x, &y, &mut w)
        l.backward()         // no tape at run time
        w -= 0.05 * w.grad()
        w.zero_grad()
    }
    println("w = [{w[0, 0]:.2}, {w[1, 0]:.2}]")
    return 0
}

// Least squares: find w so that x @ w = y.
@grad(wrt: [w])
func loss(
    x: &Tensor<f32, [3, 2]>,
    y: &Tensor<f32, [3, 1]>,
    w: &mut Tensor<f32, [2, 1]>
) -> Tensor<f32, []> {
    val r = x @ w - y    // [3, 2] @ [2, 1], checked
    Tensor::scalar((&r * &r).mean())
}

func main() -> i32 {
    val x: Tensor<f32, [3, 2]> =
        [[1.0, 2.0], [2.0, 0.0], [3.0, 1.0]]
    val y: Tensor<f32, [3, 1]> = [[5.0], [2.0], [5.0]]
    mut w: Tensor<f32, [2, 1]> = [[0.0], [0.0]]
    for _ in 0..200 {
        val l = loss(&x, &y, &mut w)
        l.backward()         // no tape at run time
        w -= 0.05 * w.grad()
        w.zero_grad()
    }
    println("w = [{w[0, 0]:.2}, {w[1, 0]:.2}]")
    return 0
}

$ neurc run least_squares.nr
w = [1.00, 2.00]

The loss surface of least_squares.nr. Each ring is a contour of equal loss; the line is the 200 steps of w -= 0.05 * w.grad(), ending at the minimum the binary prints.

Then all the way down.

The same file, stage by stage, from source to a binary that prints the answer. Most AI code is written twice, a model in Python and a fast path in C++ or CUDA; this is one language from the training loop to the kernel.

Source
least_squares.nr
One file. The data, the loss, its gradient and the training loop are all Neuro.
Lexer, parser, AST
syntax
Tokens become a syntax tree. A parse error stops the build here, located to the line and column.
Semantic analysis
types and shapes
Every type is inferred and checked, tensor shapes included. This is the stage that refused [3, 2] @ [3, 1], and it reports every error in the file, not just the first.
HIR lowering and @grad
neuro-hir
The AST becomes typed High-Level IR, the contract every backend lowers from. Reverse-mode differentiation runs here as a source-to-source transform, while the shapes are still in the types.
the loss you wrotedefine noundef ptr @loss(ptr nofree readonly captures(none) %0, ptr nofree readonly captures(none) %1, ptr nofree readonly captures(none) %2) local_unnamed_addr {
the reverse pass @grad wrotedefine { ptr, { ptr } } @__loss__rev(ptr nofree readonly captures(none) %0, ptr nofree readonly captures(none) %1, ptr nofree readonly captures(none) %2) local_unnamed_addr {
neurc compile -O 3 --emit llvm-ir least_squares.nr
Three backends
LLVM 23, MLIR 23
HIR splits by what the code is, and each kind takes its own path to machine code.
General code
inkwell, LLVM 23
Scalars, structs, control flow and ownership go straight from HIR to LLVM IR and on to object code.
Tensor code
MLIR 23: linalg, tensor, vector
Every tensor operation lowers through MLIR and is bufferized to the LLVM dialect, on the host as well as the GPU.
GPU code
nvvm (PTX), rocdl (AMD)
@gpu and @kernel functions compile to NVIDIA or AMD kernels. Reductions fold in the order the host folds, so the bits match.

Link, then run

native executable

One binary. No interpreter, no garbage collector, no gradient tape recorded while it trains.

$ neurc compile -O 3 least_squares.nr
Successfully compiled least_squares.nr -> least_squares
$ ./least_squares
w = [1.00, 2.00]

Lands where C++ and Rust land.

neurc compile -O 3 runs LLVM's -O3 pipeline, the level the C++ and Rust versions are built at, all three for generic x86-64. Best of nine runs on a Core i5-14600K, lower is better. The harness builds every version of each program and refuses to report a time if their outputs disagree.

CPU benchmarks, best of nine runs in milliseconds, lower is better
Program	Neuro -O 3	clang++ -O3	rustc -O3	Python 3.14	NumPy
mandelbrotscalar f64 in a tight loop	166 ms, fastest	166 ms, fastest	166 ms, fastest	6,668 ms	1,268 ms
vector_sumVec push, indexed sweep	24 ms, fastest	26 ms	24 ms, fastest	6,008 ms	130 ms
call_overheadrecursion, call and inline cost	49 ms	51 ms	48 ms, fastest	1,409 ms	–
print_linesinteger holes to standard output	13 ms, fastest	20 ms	13 ms, fastest	111 ms	–
format_floatsf64 holes at a fixed precision	115 ms	110 ms	38 ms, fastest	222 ms	–
int_divideguarded / and %, opaque divisor	95 ms	88 ms, fastest	89 ms	1,515 ms	–
matmul@ on [256, 256] f32 tensors	3.5 ms, fastest	3.9 ms	3.8 ms	770 ms	61 ms

Bars on a log scale from 1 ms to 10 s. A dash: the work does not vectorize, so there is no NumPy version.

On the GPU, against PyTorch.

Neuro runs its side as @gpu kernels on an RTX 5070, against PyTorch on the same card and NumPy on the CPU, moving the same data.

These are whole-program times, and both GPU columns start with a fixed cost: about 220 ms for a Neuro program, most of it the CUDA driver starting up, and about 1100 ms for PyTorch's import and CUDA setup. Timed warm inside one process, PyTorch is ahead on all four. There is no tensor-core path yet.

Warm, inside one process, in milliseconds
Program	Neuro	PyTorch
gpu_relax	~44	23
gpu_reduce	~530	56
gpu_matmul	~40	37
gpu_mlp	~25	13

How to reproduce these

GPU benchmarks, whole-program time in milliseconds, lower is better
Program	Neuro @gpu	PyTorch (CUDA)	NumPy (CPU)
gpu_relax200 fused element-wise steps on [2048, 2048]	262 ms, fastest	1,080 ms	619 ms
gpu_reduce1000 rounds of a whole and a row .sum()	747 ms, fastest	1,144 ms	1,251 ms
gpu_matmulfive [2048, 2048] f32 products	292 ms	1,137 ms	217 ms, fastest
gpu_mlptwenty batches through a two-layer perceptron	275 ms	1,133 ms	158 ms, fastest

Bars on a log scale from 100 ms to 2 s.

4 of 10 phases shipped.

The first 4 built the compiler: the language, shape-checked tensors, autodiff and GPU kernels. The next two turn it into something you train models with, and the rest make it fast at scale and easy to ship. Completing phase N ships version N + 1.

Full roadmap

1 · v2
Core language, shipped
2 · v3
Tensors and MLIR, shipped
3 · v4
Automatic differentiation, shipped
4 · v5
GPU acceleration, shipped
5 · v6
Language and backend completion, in progress
6 · v7
Neural network library, planned
7 · v8
Parallelism and scale, planned
8 · v9
Interop and deployment, planned
9 · v10
Developer experience, planned
10 · v11
Distribution and optimization, planned

Language and backend completion

Phase 5, in progress, ships as v6.0.0

Everything a standard library written in Neuro needs, on a single tensor backend. When this phase closes, a layer can be a generic struct and an optimizer can be generic over any model.

5A: One tensor backendMLIR becomes the only tensor lowering, and matmul gets a tiled, vectorized schedule.
5B: Core languageGeneric methods, closure capture modes, references in structs.
5C: Tensor typesGeneric element types, named dynamic extents, masks, FP8.
5D: Standard librarystd written in Neuro, @test, safetensors weights.

Neural network library

Phase 6, next, ships as v7.0.0

Layers, optimizers and a DataLoader, written in Neuro, where a gradient is a plain typed value shaped exactly like the model. It ends with training benchmarks against PyTorch on the same seed and data.

train.nr · planned syntax, does not compile yet

for batch in loader.epoch(&mut rng) {
    val (loss, g) = grad(model.loss(&batch.x, &batch.y))
    opt.step(&mut model, &g)
}

for batch in loader.epoch(&mut rng) {
    val (loss, g) = grad(model.loss(&batch.x, &batch.y))
    opt.step(&mut model, &g)
}

Write your first Neuro program.

Every loss ends as a single number. Start with hello.nr, then run the program this page followed and check that it prints the same w the bowl came to rest at.

Install neurc Browse examples

Requires: Rust 1.98.1+, LLVM and MLIR 23,
a C linker
Platforms: Linux, macOS, Windows
GPU: Optional: NVIDIA or AMD, on Linux

Install Neuro

Requires Rust 1.98.1+, LLVM and MLIR 23, and a C linker

terminal

git clone https://github.com/PanzerPeter/Neuro.git
cd Neuro
cargo build --release
cargo install --path compiler/neurc

git clone https://github.com/PanzerPeter/Neuro.git
cd Neuro
cargo build --release
cargo install --path compiler/neurc

Run your first program

neurc run hello.nr, or neurc compile for a native binary

hello.nr

func main() -> i32 {
    println("Hello, Neuro!")
    return 0
}

func main() -> i32 {
    println("Hello, Neuro!")
    return 0
}

Fit the model from this page

Copy it, run it, and check the w it prints

least_squares.nr

// Least squares: find w so that x @ w = y.
@grad(wrt: [w])
func loss(
    x: &Tensor<f32, [3, 2]>,
    y: &Tensor<f32, [3, 1]>,
    w: &mut Tensor<f32, [2, 1]>
) -> Tensor<f32, []> {
    val r = x @ w - y    // [3, 2] @ [2, 1], checked
    Tensor::scalar((&r * &r).mean())
}

func main() -> i32 {
    val x: Tensor<f32, [3, 2]> =
        [[1.0, 2.0], [2.0, 0.0], [3.0, 1.0]]
    val y: Tensor<f32, [3, 1]> = [[5.0], [2.0], [5.0]]
    mut w: Tensor<f32, [2, 1]> = [[0.0], [0.0]]
    for _ in 0..200 {
        val l = loss(&x, &y, &mut w)
        l.backward()         // no tape at run time
        w -= 0.05 * w.grad()
        w.zero_grad()
    }
    println("w = [{w[0, 0]:.2}, {w[1, 0]:.2}]")
    return 0
}

// Least squares: find w so that x @ w = y.
@grad(wrt: [w])
func loss(
    x: &Tensor<f32, [3, 2]>,
    y: &Tensor<f32, [3, 1]>,
    w: &mut Tensor<f32, [2, 1]>
) -> Tensor<f32, []> {
    val r = x @ w - y    // [3, 2] @ [2, 1], checked
    Tensor::scalar((&r * &r).mean())
}

func main() -> i32 {
    val x: Tensor<f32, [3, 2]> =
        [[1.0, 2.0], [2.0, 0.0], [3.0, 1.0]]
    val y: Tensor<f32, [3, 1]> = [[5.0], [2.0], [5.0]]
    mut w: Tensor<f32, [2, 1]> = [[0.0], [0.0]]
    for _ in 0..200 {
        val l = loss(&x, &y, &mut w)
        l.backward()         // no tape at run time
        w -= 0.05 * w.grad()
        w.zero_grad()
    }
    println("w = [{w[0, 0]:.2}, {w[1, 0]:.2}]")
    return 0
}

$ neurc run least_squares.nr
w = [1.00, 2.00]

Shapes in the types.Gradients in the compiler.

Install neurc Read the docs

Alpha · phase 5 of 10 in progress · source on GitHub

The shape is part of the type.

Tensor<f32, [3, 2]> is a type, not a comment. x has three rows and two columns, w has two rows and one column, and the compiler knows both before anything runs.

func loss(
    x: &Tensor<f32, [3, 2]>,
    y: &Tensor<f32, [3, 1]>,
    w: &mut Tensor<f32, [2, 1]>
) -> Tensor<f32, []> {

func loss(
    x: &Tensor<f32, [3, 2]>,
    y: &Tensor<f32, [3, 1]>,
    w: &mut Tensor<f32, [2, 1]>
) -> Tensor<f32, []> {

A batch axis that changes at run time is written ?, as in Tensor<f32, [?, 4]>: that one axis opts out and every other axis is still checked. Dynamic shapes

`@` is checked where you write it.

[M, K] @ [K, N] gives [M, N], so x's columns must match w's rows. Here K is 2 on both sides: the product is a [3, 1] and - y lines up with it.

val r = x @ w - y    // [3, 2] @ [2, 1], checked

val r = x @ w - y    // [3, 2] @ [2, 1], checked

Change one number and the build stops.

Make w a [3, 1] and neurc check refuses the file. Not a crash ninety minutes into training: a located error, before a binary exists.

w: &mut Tensor<f32, [3, 1]>

w: &mut Tensor<f32, [3, 1]>

$ neurc check least_squares.nr

Type errors found in "least_squares.nr":
error: the operands of `@` do not multiply: &Tensor<f32, [3, 2]> against &mut Tensor<f32, [3, 1]>; matrix multiplication takes two rank-2 tensors whose inner axes agree, `[M, K] @ [K, N]` giving `[M, N]`
 --> least_squares.nr:8:13
  |
8 |     val r = x @ w - y
  |             ^^^^^

Error: 1 type error(s) found

The compiler writes the backward pass.

Checked: every derivative rule against finite differences
Second order: order: 2 and .hessian() for curvature
Fenced: .detach() and @no_grad stop the gradient
Typed: the gradient has the parameter’s exact shape

least_squares.nr

// Least squares: find w so that x @ w = y.
@grad(wrt: [w])
func loss(
    x: &Tensor<f32, [3, 2]>,
    y: &Tensor<f32, [3, 1]>,
    w: &mut Tensor<f32, [2, 1]>
) -> Tensor<f32, []> {
    val r = x @ w - y    // [3, 2] @ [2, 1], checked
    Tensor::scalar((&r * &r).mean())
}

func main() -> i32 {
    val x: Tensor<f32, [3, 2]> =
        [[1.0, 2.0], [2.0, 0.0], [3.0, 1.0]]
    val y: Tensor<f32, [3, 1]> = [[5.0], [2.0], [5.0]]
    mut w: Tensor<f32, [2, 1]> = [[0.0], [0.0]]
    for _ in 0..200 {
        val l = loss(&x, &y, &mut w)
        l.backward()         // no tape at run time
        w -= 0.05 * w.grad()
        w.zero_grad()
    }
    println("w = [{w[0, 0]:.2}, {w[1, 0]:.2}]")
    return 0
}

// Least squares: find w so that x @ w = y.
@grad(wrt: [w])
func loss(
    x: &Tensor<f32, [3, 2]>,
    y: &Tensor<f32, [3, 1]>,
    w: &mut Tensor<f32, [2, 1]>
) -> Tensor<f32, []> {
    val r = x @ w - y    // [3, 2] @ [2, 1], checked
    Tensor::scalar((&r * &r).mean())
}

func main() -> i32 {
    val x: Tensor<f32, [3, 2]> =
        [[1.0, 2.0], [2.0, 0.0], [3.0, 1.0]]
    val y: Tensor<f32, [3, 1]> = [[5.0], [2.0], [5.0]]
    mut w: Tensor<f32, [2, 1]> = [[0.0], [0.0]]
    for _ in 0..200 {
        val l = loss(&x, &y, &mut w)
        l.backward()         // no tape at run time
        w -= 0.05 * w.grad()
        w.zero_grad()
    }
    println("w = [{w[0, 0]:.2}, {w[1, 0]:.2}]")
    return 0
}

$ neurc run least_squares.nr
w = [1.00, 2.00]

The loss surface of least_squares.nr. Each ring is a contour of equal loss; the line is the 200 steps of w -= 0.05 * w.grad(), ending at the minimum the binary prints.

Then all the way down.

Source
least_squares.nr
One file. The data, the loss, its gradient and the training loop are all Neuro.
Lexer, parser, AST
syntax
Tokens become a syntax tree. A parse error stops the build here, located to the line and column.
Semantic analysis
types and shapes
Every type is inferred and checked, tensor shapes included. This is the stage that refused [3, 2] @ [3, 1], and it reports every error in the file, not just the first.
HIR lowering and @grad
neuro-hir
The AST becomes typed High-Level IR, the contract every backend lowers from. Reverse-mode differentiation runs here as a source-to-source transform, while the shapes are still in the types.
the loss you wrotedefine noundef ptr @loss(ptr nofree readonly captures(none) %0, ptr nofree readonly captures(none) %1, ptr nofree readonly captures(none) %2) local_unnamed_addr {
the reverse pass @grad wrotedefine { ptr, { ptr } } @__loss__rev(ptr nofree readonly captures(none) %0, ptr nofree readonly captures(none) %1, ptr nofree readonly captures(none) %2) local_unnamed_addr {
neurc compile -O 3 --emit llvm-ir least_squares.nr
Three backends
LLVM 23, MLIR 23
HIR splits by what the code is, and each kind takes its own path to machine code.
General code
inkwell, LLVM 23
Scalars, structs, control flow and ownership go straight from HIR to LLVM IR and on to object code.
Tensor code
MLIR 23: linalg, tensor, vector
Every tensor operation lowers through MLIR and is bufferized to the LLVM dialect, on the host as well as the GPU.
GPU code
nvvm (PTX), rocdl (AMD)
@gpu and @kernel functions compile to NVIDIA or AMD kernels. Reductions fold in the order the host folds, so the bits match.

Link, then run

native executable

One binary. No interpreter, no garbage collector, no gradient tape recorded while it trains.

$ neurc compile -O 3 least_squares.nr
Successfully compiled least_squares.nr -> least_squares
$ ./least_squares
w = [1.00, 2.00]

Lands where C++ and Rust land.

CPU benchmarks, best of nine runs in milliseconds, lower is better
Program	Neuro -O 3	clang++ -O3	rustc -O3	Python 3.14	NumPy
mandelbrotscalar f64 in a tight loop	166 ms, fastest	166 ms, fastest	166 ms, fastest	6,668 ms	1,268 ms
vector_sumVec push, indexed sweep	24 ms, fastest	26 ms	24 ms, fastest	6,008 ms	130 ms
call_overheadrecursion, call and inline cost	49 ms	51 ms	48 ms, fastest	1,409 ms	–
print_linesinteger holes to standard output	13 ms, fastest	20 ms	13 ms, fastest	111 ms	–
format_floatsf64 holes at a fixed precision	115 ms	110 ms	38 ms, fastest	222 ms	–
int_divideguarded / and %, opaque divisor	95 ms	88 ms, fastest	89 ms	1,515 ms	–
matmul@ on [256, 256] f32 tensors	3.5 ms, fastest	3.9 ms	3.8 ms	770 ms	61 ms

Bars on a log scale from 1 ms to 10 s. A dash: the work does not vectorize, so there is no NumPy version.

On the GPU, against PyTorch.

Neuro runs its side as @gpu kernels on an RTX 5070, against PyTorch on the same card and NumPy on the CPU, moving the same data.

Warm, inside one process, in milliseconds
Program	Neuro	PyTorch
gpu_relax	~44	23
gpu_reduce	~530	56
gpu_matmul	~40	37
gpu_mlp	~25	13

How to reproduce these

GPU benchmarks, whole-program time in milliseconds, lower is better
Program	Neuro @gpu	PyTorch (CUDA)	NumPy (CPU)
gpu_relax200 fused element-wise steps on [2048, 2048]	262 ms, fastest	1,080 ms	619 ms
gpu_reduce1000 rounds of a whole and a row .sum()	747 ms, fastest	1,144 ms	1,251 ms
gpu_matmulfive [2048, 2048] f32 products	292 ms	1,137 ms	217 ms, fastest
gpu_mlptwenty batches through a two-layer perceptron	275 ms	1,133 ms	158 ms, fastest

Bars on a log scale from 100 ms to 2 s.

4 of 10 phases shipped.

Full roadmap

1 · v2
Core language, shipped
2 · v3
Tensors and MLIR, shipped
3 · v4
Automatic differentiation, shipped
4 · v5
GPU acceleration, shipped
5 · v6
Language and backend completion, in progress
6 · v7
Neural network library, planned
7 · v8
Parallelism and scale, planned
8 · v9
Interop and deployment, planned
9 · v10
Developer experience, planned
10 · v11
Distribution and optimization, planned

Language and backend completion

Phase 5, in progress, ships as v6.0.0

Everything a standard library written in Neuro needs, on a single tensor backend. When this phase closes, a layer can be a generic struct and an optimizer can be generic over any model.

5A: One tensor backendMLIR becomes the only tensor lowering, and matmul gets a tiled, vectorized schedule.
5B: Core languageGeneric methods, closure capture modes, references in structs.
5C: Tensor typesGeneric element types, named dynamic extents, masks, FP8.
5D: Standard librarystd written in Neuro, @test, safetensors weights.

Neural network library

Phase 6, next, ships as v7.0.0

train.nr · planned syntax, does not compile yet

for batch in loader.epoch(&mut rng) {
    val (loss, g) = grad(model.loss(&batch.x, &batch.y))
    opt.step(&mut model, &g)
}

for batch in loader.epoch(&mut rng) {
    val (loss, g) = grad(model.loss(&batch.x, &batch.y))
    opt.step(&mut model, &g)
}

Write your first Neuro program.

Every loss ends as a single number. Start with hello.nr, then run the program this page followed and check that it prints the same w the bowl came to rest at.

Install neurc Browse examples

Requires: Rust 1.98.1+, LLVM and MLIR 23,
a C linker
Platforms: Linux, macOS, Windows
GPU: Optional: NVIDIA or AMD, on Linux

Install Neuro

Requires Rust 1.98.1+, LLVM and MLIR 23, and a C linker

terminal

git clone https://github.com/PanzerPeter/Neuro.git
cd Neuro
cargo build --release
cargo install --path compiler/neurc

git clone https://github.com/PanzerPeter/Neuro.git
cd Neuro
cargo build --release
cargo install --path compiler/neurc

Run your first program

neurc run hello.nr, or neurc compile for a native binary

hello.nr

func main() -> i32 {
    println("Hello, Neuro!")
    return 0
}

func main() -> i32 {
    println("Hello, Neuro!")
    return 0
}

Fit the model from this page

Copy it, run it, and check the w it prints

least_squares.nr

// Least squares: find w so that x @ w = y.
@grad(wrt: [w])
func loss(
    x: &Tensor<f32, [3, 2]>,
    y: &Tensor<f32, [3, 1]>,
    w: &mut Tensor<f32, [2, 1]>
) -> Tensor<f32, []> {
    val r = x @ w - y    // [3, 2] @ [2, 1], checked
    Tensor::scalar((&r * &r).mean())
}

func main() -> i32 {
    val x: Tensor<f32, [3, 2]> =
        [[1.0, 2.0], [2.0, 0.0], [3.0, 1.0]]
    val y: Tensor<f32, [3, 1]> = [[5.0], [2.0], [5.0]]
    mut w: Tensor<f32, [2, 1]> = [[0.0], [0.0]]
    for _ in 0..200 {
        val l = loss(&x, &y, &mut w)
        l.backward()         // no tape at run time
        w -= 0.05 * w.grad()
        w.zero_grad()
    }
    println("w = [{w[0, 0]:.2}, {w[1, 0]:.2}]")
    return 0
}

// Least squares: find w so that x @ w = y.
@grad(wrt: [w])
func loss(
    x: &Tensor<f32, [3, 2]>,
    y: &Tensor<f32, [3, 1]>,
    w: &mut Tensor<f32, [2, 1]>
) -> Tensor<f32, []> {
    val r = x @ w - y    // [3, 2] @ [2, 1], checked
    Tensor::scalar((&r * &r).mean())
}

func main() -> i32 {
    val x: Tensor<f32, [3, 2]> =
        [[1.0, 2.0], [2.0, 0.0], [3.0, 1.0]]
    val y: Tensor<f32, [3, 1]> = [[5.0], [2.0], [5.0]]
    mut w: Tensor<f32, [2, 1]> = [[0.0], [0.0]]
    for _ in 0..200 {
        val l = loss(&x, &y, &mut w)
        l.backward()         // no tape at run time
        w -= 0.05 * w.grad()
        w.zero_grad()
    }
    println("w = [{w[0, 0]:.2}, {w[1, 0]:.2}]")
    return 0
}

$ neurc run least_squares.nr
w = [1.00, 2.00]

Shapes in the types.Gradients in the compiler.

The shape is part of the type.

@ is checked where you write it.

Change one number and the build stops.

The compiler writes the backward pass.

Then all the way down.

Source

Lexer, parser, AST

Semantic analysis

HIR lowering and @grad

Three backends

General code

Tensor code

GPU code

Link, then run

Lands where C++ and Rust land.

On the GPU, against PyTorch.

4 of 10 phases shipped.

Language and backend completion

Neural network library

Write your first Neuro program.

Install Neuro

Run your first program

Fit the model from this page

Shapes in the types.Gradients in the compiler.

The shape is part of the type.

@ is checked where you write it.

Change one number and the build stops.

The compiler writes the backward pass.

Then all the way down.

Source

Lexer, parser, AST

Semantic analysis

HIR lowering and @grad

Three backends

General code

Tensor code

GPU code

Link, then run

Lands where C++ and Rust land.

On the GPU, against PyTorch.

4 of 10 phases shipped.

Language and backend completion

Neural network library

Write your first Neuro program.

Install Neuro

Run your first program

Fit the model from this page

`@` is checked where you write it.

`@` is checked where you write it.