The story
Rail started as a Rust project in January 2026. Three months later, it has four backends and trains its own AI.
Programming languages. Autonomous systems. AI that writes code verified by the compiler it runs on. I like making things that work with minimal resources.
See what I buildAbout meBuilt from scratch in 3 months. It compiles itself — the output is byte-identical. Runs on ARM, x86, Linux, and in your browser via WebAssembly. Try it live below.
Gemma 4 fine-tuned on Rail. The compiler verifies the AI's output — if it compiles, the code is correct. 14/30 benchmark, 7,600+ verified programs, model improves by writing the language it's tested by.
Real-time neural control running at microsecond speed. The language IS the inference engine. Competition entry in progress.
Three nodes, three architectures. ARM64 compiles and serves. CUDA trains models. Edge nodes run at the perimeter. All coordinated by software written in the language.
v2.0.0 // 2026-04-04
4,400 lines of Rail compile to ARM64, x86_64, Linux, and WASM. Native IEEE 754 floats. Conservative mark-sweep GC in assembly. Closures, ADTs, pattern matching — all running in your browser. Zero C dependencies.
View on GitHubRead the story
I like building things that work with minimal resources. Most of my time goes into Rail and the infrastructure around it. Before that I spent nine years running a food production business, which taught me that systems need to be reliable before they can be clever.
Rail started as a Rust project in January 2026. Three months later, it has four backends and trains its own AI.
4,400 lines. Source in, native binary out. Four targets from one compiler.
512MB bump arena
+ GC + free list
Conservative
mark-sweep
Tagged pointers
TCO + closures
Full technical details on /system
These Rail programs are compiled to WebAssembly and run in your browser. No server. No install.
main =
let _ = print "Hello from Rail!"
let _ = print "Running as WebAssembly."
0fib n =
if n < 2 then n
else fib (n - 1) + fib (n - 2)
main =
let _ = print (fib 10)
let _ = print (fib 20)
let _ = print (fib 30)
0square x = x * x
cube x = x * x * x
main =
let _ = print (square 7)
let _ = print (cube 5)
let _ = print (square 12 + cube 3)
0main =
let xs = [10, 20, 30, 40]
let _ = print (show (head xs))
let _ = print (show (length xs))
let _ = print (show (head (tail (tail xs))))
0type Shape =
| Circle r
| Rect w h
area s = match s
| Circle r -> r * r * 3
| Rect w h -> w * h
main =
let _ = print (show (area (Circle 5)))
let _ = print (show (area (Rect 4 7)))
let _ = print (show (area (Circle 10)))
0apply f x = f x
main =
let scale = 10
let mul = \x -> x * scale
let _ = print (show (apply mul 7))
let offset = 100
let add = \x -> x + offset
let _ = print (show (apply add 42))
0fizzbuzz n = if n > 20 then 0
else
let _ = if (n % 15) == 0
then print "FizzBuzz"
else if (n % 3) == 0
then print "Fizz"
else if (n % 5) == 0
then print "Buzz"
else print (show n)
fizzbuzz (n + 1)
main =
let _ = fizzbuzz 1
0The compiler is the oracle. If it compiles, the code is correct. The model gets better at writing the language it is verified by.
benchmark (46%)
verified examples
nodes (ARM64 + CUDA + Edge)
Real-time neural control with native float MLP. Rail as the inference engine. Competition entry in progress.
ARM64 primary + CUDA training node + edge compute. Rail fleet agents, QLoRA training, cross-compilation. 3 architectures, 38 TOPS.
Rail compiles to WebAssembly. Built-in HTTP server and REPL. Programs run in browsers, on servers, and at the edge.
Autonomous oversight. One file, one loop, one LLM. Open source.