Navigation
Syntax Guide
Learn Logic
StudioCratesRoadmapContactNewsBenchmarks
GitHub

LOGOS Roadmap

v0.11.0

From English sentences to a verified compilation stack: first-order logic, full-stack websites, native, GPU and WebAssembly backends, hardware model checking, a kernel-certified proof core, and circuits compiled from the program itself.

Featured milestones

Core TranspilerComplete

English to first-order logic. A two-stage lexer with morphology and lexicon lookup, a recursive-descent parser over an arena AST with Discourse Representation Structures, Montague-style lambda semantics, and a Neo-Davidsonian event-semantics transpiler. Quantifier scope, relative clauses, negation, and modality, rendered to a collapsed SimpleFOL or full Unicode with event variables.

Two-stage lexerRecursive-descent parserDRS discourse trackingLambda semanticsQuantifier scopeEvent semanticsUnicode / ASCII / LaTeX
"Every user who has a key enters the room."
↓
∀x(((User(x) ∧ ∃y((Key(y) ∧ Have(x, y)))) → Enter(x, Room)))
Web Platform & StudioComplete

A Dioxus/WASM front end with prerendered pages. The Studio is a browser IDE: every mode edits in one code editor, with the language server running in the page — VS Code-style hovers, problems underlined as you type, keywords coloured the way the lexer reads them — and a debugger that steps a program forward and back through time. The Syntax Guide's examples are live editors too, and Learn is a structured curriculum of lessons, exercises and tests.

Dioxus WASMPrerendered pagesStudio IDEIn-browser language serverTime-travel debuggerLive Syntax GuideLearn curriculum
Imperative LanguageComplete

LOGOS as a general-purpose language: functions, structs, enums, pattern matching, a standard library, and I/O, parsed in the imperative mode of the same front end. Codegen emits Rust source plus C, Python, and TypeScript FFI bindings.

FunctionsStructs & enumsPattern matchingStandard libraryC / Python / TS FFI
## To greet (name: Text) -> Text: Return "Hello, " combined with name.
↓
Rust
#[inline] fn greet(name: String) -> String { return format!("{}{}", "Hello, ", name); }
Type SystemComplete

Refinement types, generics, sum types, and type inference, with constraints expressed in English. Escape, ownership, and liveness analysis run ahead of codegen and reject use-after-move.

Refinement typesGenericsSum typesType inferenceOwnership & escape analysis
## Main Let age: Int where it > 0 be 25. Show age.
↓
Rust
let age: i64 = 25; debug_assert!(age > 0); show(&age);
Concurrency & ActorsComplete

Channels, agents, structured parallelism, and select with timeout, lowering to async/await. Go-style concurrency written in English.

ChannelsAgentsStructured parallelismSelect with timeoutasync / await
## To worker: Show "worker done". ## Main Launch a task to worker. Show "main continues".
↓
Rust
#[tokio::main] async fn main() { tokio::spawn(async move { worker(); }); show(&String::from("main continues")); }
Distributed SystemsComplete

CRDTs, P2P gossip, and persistent storage for local-first applications with automatic conflict resolution.

CRDTsP2P gossipPersistenceConvergent countersAutomatic merge
## Definition A Counter is Shared and has: points: ConvergentCount. ## Main Let mutable c be a new Counter. Increase c's points by 10. Show c's points.
↓
Rust
pub struct Counter { pub points: GCounter, } impl Merge for Counter { fn merge(&mut self, other: &Self) { self.points.merge(&other.points); } }
Security & PoliciesComplete

Capability-based security with policy blocks and check guards: who can do what, stated in English and lowered to predicate checks.

Policy blocksCapabilitiesCheck guardsPredicates
## Definition A User has: a role, which is Text. ## Policy A User is admin if the user's role equals "admin". ## Main Let u be a new User with role "admin". Check that the u is admin. Show "passed".
↓
Rust
impl User { pub fn is_admin(&self) -> bool { self.role == "admin" } } // at the check site: if !u.is_admin() { panic_with("Security Check Failed: u is admin"); }
Proof AssistantComplete

A Calculus of Inductive Constructions kernel as the trusted core: a bidirectional type checker over which propositions are types and proofs are terms. A backward-chaining search engine proposes derivations; the kernel re-checks every one. Certificate-producing arithmetic, a finite-domain grid solver, and a CDCL SAT core with an independent RUP checker sit outside the trusted base; an optional Z3 oracle never bypasses kernel certification.

CIC kernelBackward-chaining searchKernel-certified proofsCertificate-producing arithmeticCDCL + RUPGrid solverZ3 oracle (optional)
## Main Let x be 10. While x > 0 (decreasing x): Set x to x - 1.
↓
Rust
// `decreasing x` proves the metric falls each iteration let mut x = 10; while x > 0 { x = x - 1; }
Native Compilation TierComplete

Three execution tiers below the front end: generated Rust source, a register-bytecode VM with optimizer (oracle facts, GVN, LICM, DCE, scalarization, loop-split), and a native AOT/JIT path. The VM profiles hot integer/float regions and recursive functions and tiers them down through a copy-and-patch JIT — stencils stamped out by memcpy and patched at relocations — to EXODIA, a contiguous register-allocating x86-64 backend. Anything outside the supported subset declines and stays on bytecode (the deopt contract). The benchmark suite measures the codegen path against ten languages with hyperfine; runtime parity with V8/Node, and head-to-head comparison against C. Beyond Rust, the same bytecode lowers straight to WebAssembly, C, RISC-V and NVIDIA GPUs through CUDA, each backend held to the VM's behaviour by its own lock.

Bytecode VMOptimizer (GVN / LICM / DCE)Copy-and-patch JITEXODIA register-allocating x86-64Auto-memoizationWebAssembly / C / RISC-V / CUDASIMD reductionsIR peephole10-language benchmarksV8 / Node parity
## Main Let total be 0. Repeat for i from 1 to 100: Set total to total + i. Show total.
↓
Rust
let mut total = 0; for i in 1..=100 { total = total + i; } show(&total);
Hardware VerificationComplete

SystemVerilog Assertions synthesized from English specifications, with IEEE 1800-2017 and 1800-2023 coverage: property connectives, LTL temporal operators, sequence composition, abort operators, and real-valued checker variables. The model-checking engine runs bounded model checking, IC3/PDR, k-induction, Craig interpolation, and predicate-abstraction CEGAR over Z3's bitvector theory, with vacuity analysis, assume-guarantee composition, and SMT-LIB2 export.

English → SVAIEEE 1800-2017 / 1800-2023Bounded model checkingIC3 / PDRK-inductionCraig interpolationBitvector theory
Always, if req holds, then eventually ack holds.
↓
SVA
assert property (@(posedge clk) Hold_req_ |-> s_eventually(Hold_ack_));
Full-Stack WebComplete

Websites written in LOGOS, end to end. Typed routes answer on the server and components with reactive signals render in the browser; sessions, CSRF protection, static files, JSON and a PostgreSQL client written in LOGOS come in the standard library. largo build --static makes a folder for any static host, or the project builds into one server binary that shuts down gracefully, answers health checks, times out slow requests and sheds load, all set by environment variables.

Typed routesComponents & signalsSessions & CSRFPostgreSQL clientStatic exportProduction lifecycleFour example sites
## Route GET /posts/:id (id: Int) -> Text: Return "post {id}". ## Main Show route("GET", "/posts/7").
↓
Rust
#[inline] fn __route_GET__posts__id(id: i64) -> String { return format!("post {}", logicaffeine_system::io::show_string(&(id))); } // the router answers 400 unless the :id slot holds an Int, // 405 for another method on the path, 404 for any other path
Translation ValidationIn Progress

Proving the compiler's output matches its input. The logicaffeine-tv crate symbolically executes the LOGOS source into the shared verification domain and discharges equivalence with Z3 (rung 3–4: the trust boundary is the encoder, Z3, and rustc). The source-side executor and its meta-soundness oracle — cross-validating the encoder against the tree-walking interpreter — are in place, and cover deterministic concurrency too: channels and spawned tasks, and Select checked by seeded replay. The Rust-emitter-side executor that closes full source-to-Rust equivalence is the remaining work.

Symbolic executionZ3 equivalenceEncoder soundness oracleConcurrency (seeded replay)Out-of-fragment exclusion
SiliconIn Progress

The LOGOS chip. The first pieces exist: the compiler prints any program in the Silicon ISA, a soft core executes the whole ISA on a Nexys A7 FPGA with every Show compared against the VM, and a whole-program dataflow engine runs the core algorithms of every benchmark identically to the VM on its model. Hardened sky130 blocks close signoff at every corner, and two Caravel user projects, the certified DRAM command player and the whole-program engine, pass all 19 of the foundry's MPW precheck checks. The goal is a full-custom SoC where the register-VM ops are the native ISA, the copy-and-patch stencils become hardwired functional units, and the Futamura specializer configures a spatial dataflow fabric, so the compiled program is the circuit. Memory is scheduled onto scratchpads instead of guessed by a speculative cache, the crypto and codec kernels already written in LOGOS (Keccak-f[1600], the ML-KEM and ML-DSA NTTs, group-varint) get dedicated accelerators, and energy goes only to the computation that runs, toward the Landauer limit and, with reversible logic, past it. The chip is designed and checked in LOGOS itself: the same substrate emits SVA, extracts Verilog and proves BitVec(n) properties across every bus width.

Program → circuitThree-way equivalence checkingSignoff-clean Sky130 layoutLOGOS-ISA coresStencils → functional unitsFutamura dataflow fabricNo cache hierarchyPQC accelerators
Quantum BackendPlanned

A Cirq backend on the path that already takes an English specification to SystemVerilog Assertions, taking it to quantum circuits instead: the same FOL-to-target synthesis, a different target.

Cirq v2Circuit synthesisFOL-to-quantum

Release history

Next releaseIn progress
  • The wire codec's size bake-off searches representations and…
  • The CI workflows run on your own machine before they run on GitHub
  • The Futamura projections hold the language's dates, instants, times of…
  • The textbook first projection reads the program's arguments when it…
  • Every architecture of the Samba book's third tier is read from its GGUF…
  • An op nobody has written a sugar or a kernel for runs on the spatial…
  • Every RDU bundle reports what its compiler did, and its certificates…
  • SAT: a faster CDCL core, stable-mode phases with local search, and…
  • SAT: interpolation, kernel-checked refutations, partial symmetries, and…
  • Quantized releases read in place, and every weight format ggml defines
  • The SN50 gathers narrow rows from a table wider than a site's page, and…
  • A network torch.export exports brings up on the SN50 from its graph…
  • erf of X, and the error function computed alike on every tier

Plus 12 changes and 31 fixes since v0.11.0.

v0.11.02026-11-02LGX: full-stack web applications in LOGOS, tested where they run→v0.10.12026-07-11Prebuilt largo-full Linux binaries now run on stock glibc→v0.10.02026-07-08Web app: query parameters survive router boot — studio deep links work→v0.9.162026-04-06IEEE 1800-2023 SVA upgrade→v0.9.152026-04-04IEEE 1800-2017 SVA expansion→v0.9.142026-04-03SVA synthesis codegen→v0.9.132026-04-03Hardware kernel types→v0.9.122026-04-02FOL-to-SVA synthesis→v0.9.112026-03-31Bitvector theory→v0.9.102026-03-30Hardware verification pipeline→v0.9.92026-03-29PE Map/CCopy support→
v0.9.82026-03-19FFI map keys/values type mismatch
v0.9.72026-03-19FFI serde for LogosSeq/LogosMap
v0.9.62026-03-19Studio file browser→
v0.9.52026-03-17LogosMap/LogosSeq escape-block APIs
v0.9.42026-03-16PE BTI source→
v0.9.32026-03-06Futamura projections
v0.9.02026-02-27Bidirectional type checker→v0.8.192026-02-15Swap pattern regression test→v0.8.182026-02-15Constant propagation string safety→v0.8.172026-02-15C codegen backend→v0.8.162026-02-15For-range loop regression→v0.8.152026-02-15TIER 1 codegen optimizations→v0.8.142026-02-15TIER 0 optimizer bedrock→
v0.8.132026-02-14Accumulator introduction
v0.8.122026-02-14Closures and interpreter expansion
v0.8.112026-02-14Peephole vec-fill pattern
v0.8.102026-02-14Direct collection indexing
v0.8.42026-02-13Multi-language benchmark suite
v0.8.22026-02-12Optimizer infrastructure→v0.8.02026-02-10LSP server→
v0.7.02026-02-01E2E test suite expansion
v0.6.02026-01-17Initial crates.io release with lockstep versioning
v0.5.52026-01-01First public release