Use cases

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.

Markdown version of this page

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