Milestones
List view
Kernel capability proof: boot a tiny Incan-authored freestanding kernel under QEMU with init logic, serial output, panic path, allocator hookup, and one low-level capability proof.
No due date•0/4 issues closedFreestanding foundations: target profiles, runtime layering, no-std build mode, panic/allocator hooks, ABI/layout controls, unsafe model, and freestanding package metadata. Release north star: humans and agents can investigate unexpected behavior, test competing explanations, and verify repairs across Oven-managed Rust and Incan projects, with inspectable evidence throughout. RFC 126 / #1638 governs delivery, following the v0.7 design gate #1639. Tracks: native debugging #1640; sessions/evidence #1641; bounded experiments and verification #1642; runtime/domain captures #1643; editor/MCP and conformance #1644. Existing freestanding foundations remain required; ownership #1611, proof-aware contracts #787, GPU #1041, and deferred Rust-syntax proposal #1612 retain their independent scope. Full deterministic replay and arbitrary foreign-runtime support are not universal acceptance promises.
No due date•0/24 issues closedFeature reopening release: resume broader language, package, registry, lifecycle, interop, docs-generation, editor, and product-surface work after the backend replacement is complete. RFC 126 design closure is an explicit release exit criterion (#1639): resolve all design questions, accept necessary integration contracts, demonstrate focused native/runtime feasibility, and promote the RFC from Draft to Planned. This prepares v0.8 investigations without requiring their full delivery in v0.7.
No due date•1/63 issues closedStabilization and public contract release: consolidate the post-cutover compiler architecture, ABI/package direction, tooling contracts, stdlib maturity, ecosystem workflows, and documentation into a coherent 1.0 surface.
No due date•0/1 issues closedAt the end of v0.6, Incan should have crossed a fundamental boundary: it is no longer a compiler whose real semantic handoff is emitted textual Rust. Incan source is understood, represented, and executed through Incan-owned compiler facts and direct lowering paths. Generated Rust may still exist where useful for debugging or inspection, but normal compilation and package behavior no longer depend on it. The compiler will have a canonical understanding of source meaning. An import, alias, local binding, member, generic binder, or re-export resolves to one compiler identity everywhere it appears—compiler diagnostics, Body IR, the LSP, codegraph tools, and backend facts. That gives us the stable semantic ground needed to evolve the language without letting backend naming accidents or namespace bugs decide behavior. The Body IR/replacement-backend work proves the new path rather than merely selecting it. Backend choice is explicit before execution, execution is recorded afterward, legacy Cargo is visibly named when selected, and a missing comparison never becomes a green result. The parity corpus becomes the release record: each supported construct is verified, migrated with an explicit disposition, or remains non-green. Only then does the replacement backend become the default and the old Rust-source semantic handoff disappear. For projects, Loaf and Oven become the authority once a project opts in. A `loaf.toml` expresses project intent; Oven resolves the graph, target, providers, plans, artifacts, cache identity, and receipts. `oven build` and `oven bake` are the build and asset-facing commands, while `incan run` and `incan test` delegate shallowly to the same plan and receipt model inside a Loaf. Cargo remains valid—but as legacy input and explicit compatibility/adoption mode. A Rust project can adopt Oven without adding Incan source; an Incan project can add bounded Rust facets; a mixed project can have separate, deliberate Incan and Rust roots. Cargo metadata remains consumable where needed, but it no longer silently becomes project authority once the project is Loaf-native. Build scripts are inert in Oven-native mode: declared cfg/generated/native/tool facts replace their directives, with explicit publisher-side harvest and receipted native/tool bake units. Procedural macros retain a separate compiler-host contract with visible policy and receipts. This makes self-hosting feasible in the practical sense: not that all compiler internals are suddenly rewritten in Incan, but that we have a trustworthy place to begin moving semantic and control-plane logic into Incan code. Rust remains the narrow host kernel—for native compilation, process boundaries, platform capabilities, and similar irreducible work—rather than the language in which Incan’s product logic must live. Finally, inspectability becomes first-class. The CLI, LSP, Architect, MCP tools, and Rust/Oven views should all answer from the same facts: what symbol this is, where it came from, which target and provider produced an artifact, what authority enabled an action, and whether the information is fresh. That is the payoff of the v0.6 architecture: Incan becomes both more self-directed and more explainable.
No due date•490/654 issues closed