The tools and showcases Lane is designed to include, each described as designed. Every entry links to its item on the roadmap, where the timing lives.
Compile-time tests and contracts
A function states what it requires with assume lines and shows what it returns with test lines, right in its declaration. The compiler runs them during the build, re-running only what changed, and writes the results to a binary report that lane report prints.
What is different. A test is one line of the declaration, not a separate function, and every promise is tested on both sides: an input that satisfies it and one that must be refused.
Roadmap: Contracts
Test runner (lanetest)
Builds each test case as a program and runs the cases in parallel, against any compiler and any target, comparing standard output, error output and exit code byte for byte. It writes JUnit output for CI.
What is different. Corrupted twins of the cases prove that the runner cannot pass a wrong result, and the same cases are checked against every target with the same expected bytes.
Roadmap: Done so far
Profiling and coverage
A profiling build records per-function call counts, time and memory, reads hardware counters for cache misses and branches, and reports line and branch coverage.
What is different. Profiling and coverage are build options: a release build is byte-identical with or without the tooling, and contains none of it.
Roadmap: Coverage and profiling
lane watch: live builds and compiler queries
On every save it builds a ready-to-run executable and reports all errors at once. Queries answer questions about signatures, references, layouts, the machine code of one function, and coverage.
What is different. Built for editors and coding agents: every answer is plain lines, one fact per line, with no parsing step.
Roadmap: lane watch and agent queries
Incremental and shared builds
A content-addressed cache holds each function's compiled code and each test result, so a build redoes only what changed. The cache can be shared across a team's machines.
What is different. The unit of caching is the function and the test result, not the file.
Roadmap: Incremental cache
Hot reload
Changes the functions of a running program as you edit them, so a game engine keeps its world loaded while the code changes.
What is different. It works on the same per-function units as the incremental cache.
Roadmap: Hot reload
The $12 server
A complete HTTP and JSON API server on SQLite with JWT authentication, built to enter the public "$12 Server Challenge": one vCPU and 2 GB of RAM.
What is different. One small native executable whose data layout, threads and tests are written in the language itself, held to the challenge's own limits.
Roadmap: The $12 server
The calculator
A native desktop calculator with exact decimal arithmetic. Every operation carries contracts, and the whole program is a tiny executable.
What is different. The contracts are the specification: the test lines of each operation are its documentation and its oracle.
Roadmap: The calculator showcase
Database kernels
Lane compiled as a library, with C-ABI exports and object files, so that a database engine can replace its SIMD kernels one at a time.
What is different. One source for every ISA replaces a hand-written copy per architecture, and each kernel keeps a scalar reference that it is tested against.
Roadmap: Library output
Quantized ML kernels
Kernels over bf16, FP8 and int4 data, with exact conversions to and from f32 and SIMD bulk conversion.
What is different. Every conversion rounds once, to nearest even, so a model gives the same bits on every processor.
Roadmap: Machine-learning number types
Game engine code
Data-oriented ECS storage in which SoA and AoS are one keyword on the array type, with packed lean types and threads in the language. Compact vertex data is a record of sn8 normals and un8 colours: 7 bytes where f32 components would take 28.
What is different. Changing a layout changes a type, not the code that uses it, and access modes make conflicts between threads checkable.
Roadmap: Game engine data,Normalized types,Threads
Web and GPU
WebAssembly modules (wasm32 and wasm64) with a generated loader, and SPIR-V shaders written in a Lane subset.
What is different. Records and math are shared between CPU code and shaders, and shader functions can be tested on the CPU.
Roadmap: WebAssembly,SPIR-V shaders