I build software that
builds itself.

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 me

What I build

A Programming Language

Built 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.

Self-Training AI

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.

Autonomous Robotics

Real-time neural control running at microsecond speed. The language IS the inference engine. Competition entry in progress.

Distributed Compute

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

The numbers

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
Rust
21,086 lines
Rail
4,400 lines
Binary
~8 MB
Binary
714 KB
Targets
1 (native)
Targets
ARM64 + x86 + Linux + WASM
Tests
92/92
Deps
as + ld (zero C deps)
Reilly Gomez
Reilly Gomez
Systems Engineer

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.

The story

Rail started as a Rust project in January 2026. Three months later, it has four backends and trains its own AI.

JAN
21K lines of Rust
Interpreter, parser, type checker, Cranelift JIT
FEB
ARM64 codegen
Native compiler written in Rail itself
MAR 16
Self-hosting
Fixed point. Rust deleted.
MAR 20
Flywheel
Self-training loop: compiler is the oracle
MAR 25
Performance
Matches C -O2. 5 instructions/iteration.
APR 2
Native floats
Unboxed IEEE 754 in d-registers. Zero heap allocation.
APR 3
v2.0.0
WASM backend, try/catch, REPL, HTTP server. 92 tests.
APR 4
GC fixed
Conservative mark-sweep GC bootstrapped via binary patching. Self-compile 100% reliable.
APR 4
WASM closures + ADTs
Pattern matching, algebraic data types, and closures running in the browser. 7 live demos.

How it works

4,400 lines. Source in, native binary out. Four targets from one compiler.

.rail
source
Lexer
tokens
Parser
AST
Codegen
ARM64 / x86 / WASM
as + ld
714K binary

Allocator

512MB bump arena
+ GC + free list

GC

Conservative
mark-sweep

Runtime

Tagged pointers
TCO + closures

Full technical details on /system

Try it live

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."
  0
fib 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)
  0
square x = x * x
cube x = x * x * x

main =
  let _ = print (square 7)
  let _ = print (cube 5)
  let _ = print (square 12 + cube 3)
  0
main =
  let xs = [10, 20, 30, 40]
  let _ = print (show (head xs))
  let _ = print (show (length xs))
  let _ = print (show (head (tail (tail xs))))
  0
type 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)))
  0
apply 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))
  0
fizzbuzz 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
  0

The flywheel

The compiler is the oracle. If it compiles, the code is correct. The model gets better at writing the language it is verified by.

COMPILERoracleGenerateCompileHarvestTrain

14/30

benchmark (46%)

7,600+

verified examples

3

nodes (ARM64 + CUDA + Edge)

Other work

Autonomous Robotics

Real-time neural control with native float MLP. Rail as the inference engine. Competition entry in progress.

Compute Fleet

ARM64 primary + CUDA training node + edge compute. Rail fleet agents, QLoRA training, cross-compilation. 3 architectures, 38 TOPS.

WASM + HTTP

Rail compiles to WebAssembly. Built-in HTTP server and REPL. Programs run in browsers, on servers, and at the edge.

Nanoversight

Autonomous oversight. One file, one loop, one LLM. Open source.

Interested in working together?

Open to remote work and collaboration.

EmailGitHub
> LEDATIC v2.0.0
targets: arm64 x86_64 linux wasm
self-compile: 92/92
floats: native ieee754 d-registers
READY