# Roadmap

> The planned order of work on Lane, with the state of each item.

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

| # | Item | State | Notes |
|---|---|---|---|
| 1 | Self-hosting | Done | The Lane compiler is written in Lane and compiles itself, on Windows, on Linux and on macOS (arm64). |
| 2 | Floats: f32 and f64 | Done | Strict IEEE arithmetic at both optimization levels, with a native square root on every target. |
| 3 | Position-independent executables | Done | Windows executables are built for address-space randomization and carry a header checksum; --resources adds an icon, a manifest and version information. |
| 4 | Visual scripting | Done | 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. |
| 5 | Inlining | Done | Small functions are inlined into their callers at -O1. |
| 6 | Contracts | Done | 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. |
| 7 | x86-64 Linux | Done | Static executables that need no C library, built with --target linux. |
| 8 | The compiler on Linux | Done | The compiler itself runs on Linux and builds itself to the same result as on Windows. |
| 9 | Optimization on every processor family | Done | x86-64 builds at -O0 and -O1; AArch64 and RISC-V 64 build at -O1. Floats are optimized on x86-64. |
| 10 | defer | Done | A statement that runs when its scope ends, for owned resources. |
| 11 | Implicit lossless number conversions | Done | A value converts to a wider type without a cast when no information can be lost. |
| 12 | Compile-time errors for impossible constants | Done | Integer division by a constant zero is an error, and so is any constant that is infinity or NaN. |
| 13 | A faster compiler | In progress | 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. |
| 14 | Register allocation | In progress | Values live in registers instead of memory. |
| 15 | Loops as fast as hand-written code | Next | 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. |
| 16 | Lane Explorer | In progress | 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. |
| 17 | WebAssembly: wasm32 and wasm64, with SIMD128 | In progress | 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. |
| 18 | Library output | In progress | 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. |
| 19 | SIMD vectors | In progress | Fixed-width vector types and operations are done, including vectors in optimized code (-O1) and a native square root. In progress: AVX2 images. |
| 20 | Exact math.fmod and math.wrap | In progress | Floating-point remainders with identical bits on every target. The % operator stays an error on floats. |
| 21 | Files and processes in the standard library | In progress | Done on Windows. In progress: the file system on Linux. macOS and the browser follow. |
| 22 | AArch64: macOS, iOS, Linux, Android, Windows | In progress | Linux and macOS (arm64) are done, with integers and floats; the compiler builds itself on macOS. iOS, Android and Windows on ARM remain. |
| 23 | RISC-V 64 with RVV | In progress | Linux programs build with integers and floats, with -O1. The RISC-V vector extension remains. |
| 24 | Faster test runs | In progress | A batched test runner and faster continuous integration, so the test programs run in less time. |
| 25 | Threads | Next | Threads in the language, running on a thread pool that the host program provides. |
| 26 | Asynchronous I/O | Next | await and job handles, so that file and network calls never block the main thread. |
| 27 | File mocks for tests | Next | Fixture files and a fake event queue, so that functions that read and write files have examples. |
| 28 | Compile-time evaluation | Next | Calls to suitable functions are evaluated while compiling, and recursion is turned into loops by the compiler. |
| 29 | The I/O event queue, sockets and windows | Next | One queue for keys, mouse, windows, timers and network events, with sockets and native windows. |
| 30 | The memory API and opt-in safety checks | Next | 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. |
| 31 | The loop optimizer and auto-vectorizer | Next | Loop optimizations, automatic vectorization and scheduling, with a per-loop report. |
| 32 | Removing the bootstrap compiler | Next | The compiler is built only from a pinned earlier build of itself, with no other toolchain in the build. |
| 33 | Windowed programs on Windows | Planned | A program can be built as a windowed program, so it starts without a console window and opens faster from Explorer or a shortcut. |
| 34 | Syntax highlighting | Planned | A TextMate grammar for editors, and highlighting and language detection for Lane files on code-hosting sites. |
| 35 | Native f16 | Planned | Half precision with the same results on every processor. |
| 36 | The calculator showcase | Planned | A first small program that shows the language end to end. |
| 37 | Coverage and profiling | Planned | Line and branch coverage and per-function timing, in builds that ask for them. |
| 38 | Generics | Planned | Compile-time type and value parameters. |
| 39 | Data-parallel loops, packed types and text types | Planned | vec and par loops, packed types and text types. |
| 40 | ECS storage | Planned | SoA and AoS as one keyword for entity-component data. |
| 41 | Incremental builds | Planned | Rebuild only what changed. |
| 42 | lane watch | Planned | A long-running mode that keeps an executable ready and answers questions about the program. |
| 43 | Hot reload | Planned | Change the functions of a running program, for game engines. |
| 44 | The $12 server | Planned | A complete HTTP and JSON API server, built for the public "$12 Server Challenge". |
| 45 | SPIR-V shaders | Planned |  |
| 46 | One language for every application | Planned | 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. |
| 47 | 32-bit targets | Planned | Nice to have. |
| 48 | Normalized types un8, un16, sn8, sn16 | Planned | Unorm and snorm values in 8 and 16 bits. |
| 49 | Machine-learning number types | Planned | bf16, FP8 and quantized integers. |

