Roadmap
The roadmap is generated directly from the LogosLang GitHub repository: every node below is an issue labelled roadmap, and every dashed line is a milestone. A milestone is a finish line: the issues above it are the work that gets Logos there, and everything below it comes later. Arrows point from a piece of work down to the work it unblocks.
- Done
- Ready
- Blocked
Dyad
The fundamental node constructing the entire Logic Graph. It is a struct only containing two fields: type and value. The type explains how the value should be interpreted. It is named Dyad because it contains exactly two fields
@exec is the callable ground: concrete-op identities carry their code, run/lower tables retire into the graph
Successor to 30's constructor slot and to the record work in 9c4b1d4; settled in discussion, July 2026 (recorded in DESIGN: The callable ground is @exec). Fixes the one remaining dishonesty that work introduced: operators are typed fn but their value is a record, not [input, output, body, bcode] — the mod-8 discriminant in identities/meta.rs is a patch over that lie.
Implement the ruled drop model: constructor-inserted defer teardown
The ruling (DESIGN.md, 2026-07-20, commit 6e8474d)
Memory management of executable code: persist and re-attach compiled artifacts so a program can stop and continue
Goal
Async: stackless tasks on user-defined pools — .await, wakers, boundary preemption, cancellation
What
Metareflection from within the language: dyad as an identity with shared methods — read a value's fields through its type
What
Ownership gates: borrow / single-owner / multi-owner as take/drop gates on references (name vs synolon lifetime)
The idea (design discussion, 2026-07-23)
seed: the command line is Logos source — argv runs as one line, `import` loads files (pub-only)
Ruling
Lexer
The lexer is a trie where a node can also match a regex, so nearly any string identification is expressible in one structure. It is the single global way to recognize identities in source text, and being a trie it is both fast and mutable.
Parser
The parser needs to know what each token from the lexer means and therefore all tokens needs to have a defined type.
Type
Everything in Logos has a type, which explains how its value is read. The type of type is type itself, the one fixed point the seed knows a priori.
Compiler
Compiling the Logic Graph to binary code. Only functions can be compiled. A set of identities are leafs which represents the IR primitives.
Create all fundamental identities
In Logos everything is an identity. In the seed other identities are needed as well like struct, i32, f64, ., &, @, (, +, language, :=, for, if, while, fn, -, and '«'. Its not necessary to make an issue for each identity as many will be made together in batches that are unknown beforehand.
mut, pub and other (new) rw gates
These aren't strictly needed in the seed but they help a lot with safety since everything should only be readable by default and also not everything should be able to read everything. Most likely everything in the seed would need read every other part of the seed and there must be a explicit rw gate for this, just like mut and pub.
Token
A token is the pending, not-yet-reduced unit on the parsing tape. There is no separate "lexer creates tokens, parser consumes tokens" two-pass flow; lexing and parsing are one constructor-driven pass.
Interpreter
The interpreter runs any give Logic Graph function without compiling anything, but it relies on at least the leaves being compiled, because the leaves is the "ground truth" in the Logic Graph and everything is fundamentally defined in through leaves at the bottom but the leaves isn't defined in other identities. They are defined but their definitions lies in the compiled and how it converts the leaves to machine-code.
The «?» identity
«?» is really important to state what is unknown. In any possible state of Logos in the future there will always be unknown things, which means there will always be things to improve, and that is why an explicit identity of what is unknown is needed. When the self-identification system gets made it will start being able to solve what should be in the «?» spots. An example is «sin(x)² + cos(x)² == ?».
Structure reflectability: node layout as graph data
Per DESIGN, the only opaque thing in v1 is a function's bcode (the exec@ callable). Everything else — nodes, types, values, scopes, a function's source body, and the layout that says how to read each node's value — must be reflectable from the Logic Graph.
Review the Parser and the ConstructFn protocol — and grow it toward tape-ops-as-identities
Context
Proof system
Creating proof system with universe, predicates and proofs.
Logic Graph renderer / visualizer
A tool to render the Logic Graph of any parsed Logos snippet, so structure, shared nodes, and resolved types are visible at a glance — for debugging "what is wrong / what is missing", and eventually a visual for the website.
CLI: the `logos` command (run a file, or REPL)
The logos command: run a file top to bottom like a script (no main), or start the REPL. Its whole job is handing source to the interpreter — no subcommands and no compile flags, because the code itself decides what compiles.
Borrow checker
FFI v1: seamless C calls (Rust and C++ ride the C ABI)
C interop is the growth engine for the years Logos has no libraries: the C ABI is the lingua franca, and winning there wins Rust (cdylib + cbindgen) and C++ (extern "C" surfaces) transitively. Zig's @cImport is the proof that automatic, near-seamless C access carries a young language — that is the bar, reached in two stages (v1 here; header ingestion after).