Topazdocs
About Topaz

Roadmap

Current product priorities and the next public release boundary.

This roadmap shows priorities and readiness, not promised dates.

Now

  • The current public product includes the explicit Self Front-end Preview on top of Bootstrap Foundations and the installed application loops.
  • Compiler, runtime, npm installer, artifacts, documentation, and Playground identify one current product.
  • The default compiler is the exact recoverable Rust Stage 0. The installed Self Front-end Preview runs the complete embedded Topaz-authored front end through Typed and compares its managed observation with Rust Stage 0 without the original source.
  • An explicit installed Stage 1 Compiler Preview consumes the Topaz-authored production path through generated Rust with complete provenance and no hidden target fallback.
  • Installed native and Python products run offline, managed browser products own their static bundle and local-data boundary, and generated services own bounded inbound HTTP authority, isolation, deadlines, observation, and shutdown.
  • Fixed-length mutable ByteBuffer supports contiguous binary work while immutable Bytes remains the snapshot and transport value across the accepted native, Python, Web, and Web Worker boundaries.
  • A maintained multi-module CodeImage kernel builds with stock installed Topaz, exposes fail-closed native-selection decisions, and preserves exact byte and fault behavior through source-free Web and Worker artifacts.
  • Run targeted differential checks when a related implementation changes. Reserve full cross-platform and full differential campaigns for the public-minor RC that owns them.

Next

  • Build the conditional Stage 2 Fixed Point from the exact Stage 1 producer while keeping Rust Stage 0 independently recoverable.
  • Require reproducible Stage 1 and Stage 2 semantic, generated-source, product, and provenance evidence before calling any result a fixed point.
  • Keep the HTTP service, local-data, browser, native, Python, and binary-media loops as non-regressing predecessor products.
  • Add no compiler-only dialect or convenience syntax. A real compiler-workload blocker still requires its own language or capability decision.

Release boundary

Bootstrap Foundations, the typed-terminal Self Front-end Preview, and the explicit Stage 1 producer are available as Topaz 5.13.0 / topaz-5.13. Use topaz compiler preview [entry] --producer stage1 --terminal rust-source --out-dir <directory> for Stage 1. The installed route records complete producer and generated-source provenance, runs source-free, preserves independent Rust Stage 0 recovery, and fails without hidden target fallback.

The next conditional public result is Topaz 5.14.0 / topaz-5.14, and it opens only when the Stage 2 Fixed Point result passes its exact gate. Completed checkpoints remain recorded in History.

Later

  • Make the self-hosted compiler kernel the default only after reproducible Stage 1/Stage 2 results, installed dual-engine agreement, and an independently usable Rust recovery path.
  • Treat self-hosting progress as an implementation milestone, not an automatic reason for a major version. A major release still requires a real incompatible user contract.
  • Keep general native aggregate layout, arbitrary host FFI, a new Web ABI, SIMD, browser fetch, outbound networking, remote package publication, router and middleware frameworks, shared server state, databases, TLS termination, WebSocket, and new syntax outside this train.
  • Preserve explicit older language modes as compatibility inputs rather than parallel current identities.

Bounded integration evidence

LIT and Lispex integration records remain useful internal compatibility and regression evidence. They do not define this release queue, make LIT a public Topaz backend, or establish whole-language equivalence. Large LIT, N-way, mutation, and differential campaigns run only when their owned semantics change or an applicable release candidate requires them.

Research

  • Expand differential and fuzzing tools that find places where code generators misunderstand the language.
  • Consider model checking or mechanized proofs only where there is a concrete artifact and a useful way to reproduce the result.
  • Keep broad optimizer work, async syntax, recoverable faults, grapheme APIs, and user-defined templates as research topics until a future language decision accepts them.