Roadmap
The order is the planned order of work: finished items first, then work under way, then the next items, then the rest. States are the state of each item on the date below, in the development compiler; the Downloads page offers the latest published release. This one data file feeds the page, its Markdown version and llms-full.txt. Updated 2026-10-28.
Done so far
- Language specification
- Standard library written in Lane: io, fmt, mem, os, bufio and float
- A test runner written in Lane, which runs the 1668 programs behind these docs
Planned order
-
Self-hosting
The Lane compiler is written in Lane and compiles itself, on Windows, on Linux and on macOS (arm64).
-
Floats: f32 and f64
Strict IEEE arithmetic at both optimization levels, with a native square root on every target.
-
Position-independent executables
Windows executables are built for address-space randomization and carry a header checksum; --resources adds an icon, a manifest and version information.
-
Visual scripting
Edit a program as a node graph side by side with its text, with the same checks and the same generated code. The program tree commands (tree, print, build --tree, nodes) are released.
-
Inlining
Small functions are inlined into their callers at -O1.
-
Contracts
assume lines and test examples on functions. The examples run during builds for every target, a failing one fails the build, float results can be stated exactly, and exported library functions can carry examples. Using assume facts in the optimizer is planned.
-
x86-64 Linux
Static executables that need no C library, built with --target linux.
-
The compiler on Linux
The compiler itself runs on Linux and builds itself to the same result as on Windows.
-
Optimization on every processor family
x86-64 builds at -O0 and -O1; AArch64 and RISC-V 64 build at -O1. Floats are optimized on x86-64.
-
defer
A statement that runs when its scope ends, for owned resources.
-
Implicit lossless number conversions
A value converts to a wider type without a cast when no information can be lost.
-
Compile-time errors for impossible constants
Integer division by a constant zero is an error, and so is any constant that is infinity or NaN.
-
A faster compiler
Target: one million lines to a runnable executable in under one second on one core without optimization, and in under three seconds at full optimization. Dated figures are on the measurements page.
-
Register allocation
Values live in registers instead of memory.
-
Loops as fast as hand-written code
At -O1, values a loop reuses stay in registers, divisions by powers of two become shifts, conditions branch directly, counters step in one instruction and calls to small functions no longer save and reload values around the call, so scalar loops run as fast as the same algorithm written by hand.
-
Lane Explorer
The compiler in the browser: source on one side, the generated code for each target on the other. In progress: a result for every contract line, so that each example shows as passed or failed.
-
WebAssembly: wasm32 and wasm64, with SIMD128
wasm32 and wasm64 modules build with the same results as x86-64, and floats are done on both. Native SIMD128 code is still to come.
-
Library output
Windows x86-64 libraries are done. In progress: a WebAssembly library mode, so that a host such as a game engine can embed Lane code. Linux shared libraries are planned.
-
SIMD vectors
Fixed-width vector types and operations are done, including vectors in optimized code (-O1) and a native square root. In progress: AVX2 images.
-
Exact math.fmod and math.wrap
Floating-point remainders with identical bits on every target. The % operator stays an error on floats.
-
Files and processes in the standard library
Done on Windows. In progress: the file system on Linux. macOS and the browser follow.
-
AArch64: macOS, iOS, Linux, Android, Windows
Linux and macOS (arm64) are done, with integers and floats; the compiler builds itself on macOS. iOS, Android and Windows on ARM remain.
-
RISC-V 64 with RVV
Linux programs build with integers and floats, with -O1. The RISC-V vector extension remains.
-
Faster test runs
A batched test runner and faster continuous integration, so the test programs run in less time.
-
Threads
Threads in the language, running on a thread pool that the host program provides.
-
Asynchronous I/O
await and job handles, so that file and network calls never block the main thread.
-
File mocks for tests
Fixture files and a fake event queue, so that functions that read and write files have examples.
-
Compile-time evaluation
Calls to suitable functions are evaluated while compiling, and recursion is turned into loops by the compiler.
-
The I/O event queue, sockets and windows
One queue for keys, mouse, windows, timers and network events, with sockets and native windows.
-
The memory API and opt-in safety checks
Virtual memory, arenas and pools in the standard library, and safety checks a program asks for. The cost of zero-initialising variables has been measured, to decide when the compiler may skip it.
-
The loop optimizer and auto-vectorizer
Loop optimizations, automatic vectorization and scheduling, with a per-loop report.
-
Removing the bootstrap compiler
The compiler is built only from a pinned earlier build of itself, with no other toolchain in the build.
-
Windowed programs on Windows
A program can be built as a windowed program, so it starts without a console window and opens faster from Explorer or a shortcut.
-
Syntax highlighting
A TextMate grammar for editors, and highlighting and language detection for Lane files on code-hosting sites.
-
Native f16
Half precision with the same results on every processor.
-
The calculator showcase
A first small program that shows the language end to end.
-
Coverage and profiling
Line and branch coverage and per-function timing, in builds that ask for them.
-
Generics
Compile-time type and value parameters.
-
Data-parallel loops, packed types and text types
vec and par loops, packed types and text types.
-
ECS storage
SoA and AoS as one keyword for entity-component data.
-
Incremental builds
Rebuild only what changed.
-
lane watch
A long-running mode that keeps an executable ready and answers questions about the program.
-
Hot reload
Change the functions of a running program, for game engines.
-
The $12 server
A complete HTTP and JSON API server, built for the public "$12 Server Challenge".
-
SPIR-V shaders
-
One language for every application
Complete applications on every platform written only in Lane: windows, a GPU-drawn UI and layout engine, input, files, network, audio, and desktop and mobile packaging, with no other language or framework in the build.
-
32-bit targets
Nice to have.
-
Normalized types un8, un16, sn8, sn16
Unorm and snorm values in 8 and 16 bits.
-
Machine-learning number types
bf16, FP8 and quantized integers.