# Use cases

> The tools and showcases Lane is designed to include, each linked to its item on the roadmap.

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](/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](/roadmap/#done)

## 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](/roadmap/#coverage-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](/roadmap/#watch)

## 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](/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](/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](/roadmap/#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](/roadmap/#calculator)

## 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](/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](/roadmap/#ml-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](/roadmap/#game-engine-data), [Normalized types](/roadmap/#normalized-types), [Threads](/roadmap/#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](/roadmap/#wasm), [SPIR-V shaders](/roadmap/#spirv)
