Skip to content
Back to milestones

0.6 Release

New issue
Open
No due date
•Last updated Sep 21, 2026

At 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.

74% complete

List view

0 issues of 164 selected