CompletedIn progressPlannedPaused
01Delivered Foundations
Completed projects that the rest of the roadmap builds on. Shipped behavior remains documented in the language reference and status matrix.
Initiative
Build & Toolchain
CLI Follow-Ups — Phase D
Complete the remaining CLI behavior and diagnostics needed for a coherent native Sailfin toolchain.
CLI Modularization
Keep compiler command orchestration modular, testable, and separate from compilation policy.
Native sfn bench Command & sfn/bench Harness
Provide a native sfn bench command and Sailfin benchmark harness for repeatable compiler and runtime measurements.
Native Toolchain Pinning & Dispatch
Let a project declare its required sfn toolchain version natively in capsule.toml ([toolchain]) and, in phase 2, auto-fetch/dispatch to it — retiring .seed-version/Makefile plumbing for downstream projects.
Initiative
Effect System & Language Core
Effect Enforcement Foundations
Deliver hierarchical effects, conservative detection, cross-capsule enforcement, and effect-transparent concurrency foundations.
Generics & Higher-Order Functions
Provide generics and higher-order collection operations with monomorphized, statically checked behavior.
02Toward 1.0
Work that currently defines Sailfin's stable 1.0 maturity boundary. This is direction, not a launch deadline or an immutable checklist.
Autodiff & Training Graphs
Add differentiation and training-graph semantics on top of the typed tensor IR and numeric substrate.
Capability-Sealed Model Artifacts
Package models with verifiable provenance, declared authority, compatibility metadata, and enforceable execution boundaries.
Distributed Accelerator Concurrency
Coordinate accelerator work and collectives through Sailfin’s structured-concurrency and capability model.
ML Acceleration — Foundations
Track-A foundations for SFEP-0052: low-precision numeric substrate, a shape-typed tensor IR + fusion, a first substrate exit, and the first enforced ![gpu]/![model] checks.
sfn/ai Model Engines & Adapters
Define native model-engine interfaces and adapters with explicit model effects, capabilities, and tensor boundaries.
Initiative
Build & Toolchain
Build Performance & Production-Readiness
Make self-hosted builds faster, more deterministic, and production-ready across supported development and release workflows.
Compiler Frontend/Backend Capsule Boundary
Split the compiler into stable frontend and backend capsule boundaries without prematurely fragmenting every compiler pass.
Compiler Hardening
Harden parsing, type checking, captures, and diagnostics so the self-hosted compiler fails predictably on real programs.
Per-Module Compile-Time Peak RSS
Measure and reduce peak compiler memory per module so production builds stay within a predictable resource envelope.
Production-Grade Self-Host Determinism Enforcement
Guarantee deterministic compiler output and reproducible builds across supported hosts and repeated self-hosting runs.
sfn LSP & IDE Integration
Provide a compiler-backed language server for diagnostics, navigation, completion, formatting, and editor integration.
Workspace Manifest & Multi-Capsule Policy
Grow workspace.toml into a production-grade multi-capsule manifest (Cargo/Go/Zig parity) plus the workspace-tier capability envelope no peer has. Design: SFEP-0051.
Initiative
Capability-Sealed Runtime
End-to-End Capability Seal
Seal executable capability declarations end to end so runtime authority matches compiler-checked effects.
Native Crypto + TLS Stack — Zero OpenSSL
Remove the OpenSSL (-lssl/-lcrypto) dependency by building a pure-Sailfin crypto + TLS 1.3 stack — a prerequisite for the capability seal (SFEP-0016).
Native Runtime Ownership & Deterministic Destruction
Complete deterministic destruction and ownership-aware runtime primitives needed for a memory-safe self-hosted runtime.
Owned Syscall Layer
Route operating-system access through owned, capability-aware syscall boundaries implemented in Sailfin.
Per-Task Capability Context
Carry capability and runtime context per task so concurrent work cannot silently inherit ambient authority.
Runtime Strings & Memory Safety
Make string operations efficient and memory-safe across slices, concatenation, aggregate reads, and ownership-sensitive cleanup.
Seal-Sufficient Native Backend
Complete the backend and syscall layer needed for capability sealing without hidden native-runtime escape hatches.
sfn/capability — Runtime Object-Capability Model
Ship reusable runtime object capabilities that make authority explicit, bounded, and testable in Sailfin programs.
Initiative
Effect System & Language Core
Capsule-Defined Decorators
Let capsules define statically resolved decorators with explicit typing, expansion, and effect behavior.
First-Class Function Values
Make functions first-class typed values that can be stored, passed, returned, and called without losing effect information.
Information-Flow & Taint Enforcement
Track sensitive data through model and capability boundaries so policy checks can prevent unintended disclosure.
Model Effect Enforcement
Enforce ![model] declarations and call boundaries as part of Sailfin’s explicit effect system.
String Interpolation Syntax
Add typed string interpolation with clear evaluation, formatting, allocation, and diagnostic semantics.
Initiative
Structured Concurrency
Concurrency Frontend Typing
Complete frontend typing for await results, typed channels, task bodies, and structured-concurrency call sites.
Concurrency Maturity Phase 1 — Cancel-on-Fault Nursery
Cancel sibling tasks when a nursery child fails, with bounded shutdown and deterministic error propagation.
Initiative
Test Infrastructure
Sailfin-Native Test Framework
Provide the native sfn test framework, discovery model, assertions, fixtures, and compiler-owned execution contract.
Test Runner Performance & Reliability
Harden test-runner reliability and improve measured performance before introducing parallel scheduling.
03Later
Important approved directions that are not currently inside the 1.0 boundary. Later does not mean rejected, and work may move as the language evolves.
Initiative
Build & Toolchain
aarch64-Linux Target Support
Bring the self-hosted compiler and installer to 64-bit ARM Linux, including ABI support, release artifacts, and on-device self-host verification.
Fine-Grained Compiler Sub-Capsules
After the frontend/backend boundary is stable, split compiler passes into smaller internal capsules where evidence shows a maintenance or performance benefit.
Makefile Retirement — sfn Owns Build/Check/Bootstrap
Retire the root Makefile by moving bootstrap, build, test, bench, and check orchestration into native `sfn` commands.
Native Windows Self-Host (MSVC ABI)
Self-host Sailfin natively on Windows with the MSVC ABI, including bootstrap, linking, tests, and release packaging.
Runtime Diagnostics & Allocation Telemetry
Add opt-in runtime diagnostics for allocation, ownership, and task behavior without changing release semantics.
WebAssembly Target
Add a WebAssembly compilation target with an explicit runtime, capability, and packaging contract.
Initiative
Capability-Sealed Runtime
Full Unsafe Capability Enforcement
Extend unsafe enforcement across the full call graph and runtime boundary after the current local checks are dependable.
Perf-Parity Native Backend
Close measured performance gaps in the fully native backend after correctness and capability sealing are established.
Transitive Capability Audit & SBOM
Audit transitive capsule authority and produce machine-readable capability provenance for builds and dependencies.
Initiative
Effect System & Language Core
Currency & Time Literals
Design exact currency and time literal syntax with explicit units, precision, overflow, and interoperability rules.
Effect Polymorphism & Effect-Aware HOFs
Let generic and higher-order code express, propagate, and constrain caller effects without erasing safety.
Pipeline Operator
Design a pipeline operator that composes cleanly with function calls, generics, effects, and diagnostics.
User-Facing Ownership & Borrow Checking
Expose ownership and borrowing rules in the language after deterministic runtime ownership is stable.
Initiative
Product & Adoption
Benchmark v2 — Adoption Readiness and Controlled Learnability
Separate real-world adoption readiness from controlled learnability, then test external pull only after a credible technical signal.
External Credibility — Evidence Before Promotion
Build trust through truthful claims, reproducible evidence, and one time-boxed outreach test before deciding whether to promote Sailfin more broadly.
MCP-Proxy Enablement
Runtime and stdlib gaps blocking a pure-Sailfin MCP proxy. Track A (stdio, 4 pure-Sailfin wrappers) is the critical path; Tracks B and C4 serve the deferred HTTP/control-plane work.
REST-Server Dogfooding Gaps
Close the language, runtime, and standard-library gaps needed to build and operate a basic REST server entirely in Sailfin.
Initiative
Structured Concurrency
Bridge the WebSocket Runtime
Connect WebSocket operations to the native runtime and structured-concurrency model without hidden blocking behavior.
Concurrency Maturity Phase 2 — Async-I/O Reactor
Replace thread-per-task blocking I/O with a portable reactor while preserving structured cancellation semantics.
Rich Synchronization & Atomics
Add the synchronization and atomic primitives justified by measured concurrent workloads after core task semantics stabilize.
Initiative
Test Infrastructure
Advanced Test Modes
Add opt-in property, fuzz, snapshot, and other advanced modes once the core native runner contract is stable.
Parallel Test Execution
Execute independent tests concurrently with deterministic reporting, isolation, and configurable resource bounds.
Test Runner Ergonomics
Improve test discovery, filtering, output, failure reporting, and day-to-day command ergonomics.
04Exploration
Concepts worth preserving while their design, sequencing, or fit remains open. These are not delivery promises.
Initiative
Build & Toolchain
Notebook & Interactive Tooling
Explore interactive execution, notebooks, and REPL-like workflows once compiler APIs and incremental behavior can support them honestly.
Initiative
Effect System & Language Core
Algebraic Effect Handlers
Explore whether algebraic handlers complement Sailfin’s explicit capability effects without weakening predictability.
How this page works
Linear plans the work; this page explains the direction
Maintainers plan Initiatives and Projects in Linear. A Project appears here only after it has been deliberately marked for public publication and assigned a reviewed horizon. Horizons can change as designs mature, dependencies move, or development accelerates. Linear links and private planning context are never exposed on this page.
Contributing
Help improve Sailfin
Public GitHub issues are the right place for bug reports and concrete proposals. Significant language, runtime, ABI, or toolchain changes should be grounded in an SFEP before implementation.
