Get Started

Roadmap

Sailfin's path from alpha to a stable 1.0 release and beyond.

Last updated April 16, 2026

Done In progress Planned

Release 1.0

7 of 57 milestones complete

Phase 1: Runtime Enablement — Systems Primitives

Language features that unblock the pure Sailfin runtime rewrite. Nothing in the runtime can be ported without these.

0/6
  • extern fn with typed linker-resolved symbols (parser ✓, emitter ✓, type-checker registration needed)
  • int (i64) and float (f64) numeric types replacing number
  • Raw pointer types (*T, *const T, *mut T) — enforced, not just parsed
  • Result<T, E> type and ? error propagation operator
  • Bitwise operators on integer types (&, |, ^, >>, <<)
  • ${} string interpolation replacing {{ }}

Phase 2: Runtime Enablement — Containers & Resources

Higher-level features needed to express typed containers, resource handles, and higher-order operations in the runtime.

0/5
  • Closures with captured variables (not just non-capturing lambdas)
  • Generic type constraints (fn sort<T: Comparable>(arr: Array<T>))
  • Deterministic drop emission — compiler emits scope-exit drop calls for owned values
  • Complete generic type inference
  • Interface conformance validation with variance checks

Phase 3: Sailfin-Native Runtime

Replace the C runtime with pure Sailfin. Depends on Phase 1 and 2 compiler features being shipped.

0/10
  • Core memory management — arena allocator, string/array allocation in Sailfin
  • String subsystem — {ptr, len, cap} layout, concat, append, substring, grapheme ops
  • Array/collection subsystem — typed Array<T>, Slice<T>, push, concat, map/filter/reduce
  • File I/O subsystem — fs.read, fs.write, fs.exists, directory ops via extern fn
  • Process execution — posix_spawnp/CreateProcessA via extern fn
  • Exception subsystem — replace TLS-flag polling or migrate to Result<T, E> internally
  • Time/clock subsystem — clock_gettime/mach_absolute_time via extern fn
  • Crypto subsystem — SHA-256, Base64 in pure Sailfin (bitwise int ops)
  • Native CLI driver — replace native_driver.c with Sailfin entry point
  • Remove the C runtime once parity and performance gates are met

Phase 4: Structured Concurrency

Concurrency primitives with capability tracking. Requires Phase 1-2 features plus atomic intrinsics.

0/6
  • Atomic intrinsics (atomic_add, atomic_cas, memory fences)
  • await expression parsing and lowering
  • routine { } block parsing and lowering
  • channel() as the core concurrency primitive
  • spawn expression
  • Runtime task scheduler and work queue

Effect System Hardening

Make the effect system world-class — Sailfin's core differentiator. Can progress in parallel with runtime work.

0/7
  • Wire effect checker into compilation gate — violations block compilation, not just diagnostics
  • Hierarchical effect enforcement (io.fs, net.http, etc.)
  • Effect polymorphism for generics (fn map<T, E>(f: Fn ![E]) ![E])
  • Transitive call-graph enforcement (if A calls B ![net], A needs ![net])
  • --fix workflow for automatically inserting missing effect annotations
  • gpu and rand effect enforcement
  • Capsule-level capability enforcement via capsule.toml

Compiler Stabilization

Build pipeline and LLVM backend correctness.

4/6
  • Eliminate the Python fixup script
  • Make build.sh the sole clean build path with no post-processing
  • Pass make check with no fallbacks
  • Deterministic self-hosting — stage2 == stage3 fixed-point verified
  • Stabilize control-flow LLVM lowering (loop/if/break headers)
  • Richer diagnostics — multi-span, severity levels, fix-it hints

Tooling & Developer Workflow

CLI tools and build toolchain modernization.

2/7
  • sfn fmt — code formatter (token-stream, one style, CI-enforced)
  • sfn check — fast type and effect analysis
  • sfn vet — static analyzer
  • sfn audit — dependency capability surface analysis
  • Replace the sfn shell wrapper with a Sailfin-native CLI binary
  • Remove Python tooling and scripts from the release pipeline
  • Remove Python runtime shims

LLM & Agent Adoption

Make Sailfin the language agents reach for when they need verifiable code. Structured tooling and training-data presence.

0/4
  • llms.txt — canonical single-file language reference for LLM context windows
  • Structured diagnostics (sfn check --json) — machine-readable error output
  • MCP server wrapping the compiler for agentic compile-check-fix loops
  • 50+ Rosetta Code / classic algorithm ports as training-data corpus

Release Pipeline Hardening

Supply-chain security and reproducible builds.

0/3
  • Signed checksums and provenance metadata with release artifacts
  • Installer CI that validates install.sh against staging artifacts
  • Only self-hosted compiler artifacts in build and release workflows

Documentation

Docs, spec, and examples aligned with compiler reality.

1/3
  • Align README, status, roadmap, and spec with compiler reality
  • Expand site docs to production-quality coverage
  • Remove legacy compiler-stage references from docs and examples

Post-1.0

These workstreams begin after a stable self-hosted toolchain ships.

Enterprise Hardening & AI Integration

Library-level AI support, taint tracking, and advanced safety features — delivered as capsules, not language syntax.

6 items
  • sfn/ai capsule — model invocation, prompt templating, generation provenance
  • Migrate model/prompt/tool/pipeline from language syntax to sfn/ai library
  • Secret<T> / PII<T> taint tracking integrated with the effect system
  • sfn lsp — language server for IDE integration
  • sfn audit enhancements — transitive capability analysis, SBOM generation
  • Ownership and borrowing enforcement (Affine<T>, Linear<T>, &T, &mut T)

Platform & Ecosystem

Runtime, tooling, and ecosystem infrastructure for post-1.0 growth.

6 items
  • Async runtime — Sailfin-native event loop, task scheduler, and channels
  • Runtime diagnostics — structured tracing and allocation telemetry
  • WebAssembly emission target
  • Native test framework — golden, adversarial, and replay test types
  • |> pipeline operator with async and lazy semantics
  • GPU effect enforcement and tensor dispatch

Exploration Backlog

Under consideration with no committed milestone.

  • unsafe capability enforcement
  • Currency literals ($0.05) and time literals (1s, 150ms)
  • Notebook and interactive tooling
  • Effect handlers (algebraic effect semantics)
  • Capability-scoped sandboxing for capsule execution

Contributing

Open an issue or start a discussion in a pull request. Tag it with the appropriate milestone label so it can be triaged against the 1.0 scope. Major design changes that affect the language or ABI should reference a written proposal in docs/proposals/ before implementation begins.

Open an Issue Contributor Guide