Skip to content

The Oven ecosystem

One authored project flows top to bottom through this map: what the author writes, how Oven resolves and plans it, how the compiler service and the direct rustc executor bake it into Loaves the store keeps, and how the registry moves those Loaves between machines. Border style carries RFC status. The two gold dotted nodes, the store's unit identity and incan.pub, are the parts still at draft RFC rather than implemented; the solid gold node is the Loaf itself, the unit everything else bakes, stores, reuses, and exchanges.

This page is a map, not a specification. Each box names the RFC that owns it, and the table at the end collects them. Where the map and an RFC disagree, the RFC is right and the map has a defect.

The Oven Ecosystem A five-tier architecture map. An authored project — two language facets, a lifecycle layer and one manifest — feeds Oven's resolver and unit graph, which draw on SDK components and an optional Cargo compatibility mode. A plan of units and identities reaches the compiler service, which exposes the Incan facet provider API back up to the unit graph and emits Rust to a direct rustc executor; that executor compiles units and seals each as a Loaf — payload, plan, identity and receipt in one immutable artifact — which a content-addressed store keeps and hands back to any later plan with the same identity. The store materialises linked outputs, and publishes the source Loaf with attested assets to the incan.pub registry, which admits assets back only on exact unit identity, projects an artifact graph, and is copied by mirrors, while crates.io is consumed as source only. Two command surfaces, incan and oven, sit beneath, with delegation running one way from incan down to oven. PROJECT · WHAT THE AUTHOR WRITES OVEN · RESOLVE AND PLAN COMPILE AND STORE REGISTRY AND SOURCES COMMAND SURFACES · RFC 118 ADVISORIES MUTATES RESOLVES WRITES LOCK SELECTS UNITS RESOLVED SELECTED COMPONENTS PLAN: UNITS + IDENTITIES PROVIDER API LEGACY PATH EMITS RUST SEALS STORED REUSES MATERIALISES PUBLISH LOAF + ASSETS IMPORTS ASSETS BY UNIT IDENTITY PROJECTS STATIC COPY EXT-SOURCE REC INDEX + LOAVES DELEGATES Incan facet .incn sources std.registry descriptors RFC 077 · 113 Rust facet conventional src/ [rust.*] for deviations only RFC 119 · LEGACY CRATE DEPS RFC 013 loaf.toml · oven.lock one authored manifest typed deps: loaf, crate, path registry identity, endpoint, trust RFC 117 · LOCK RFC 020 Project lifecycle templates · starters · mixes mutation policy · actions env matrices · receiver-owned RFC 073 · 074 · 075 · 076 · 078 Unit graph and host providers host and target domains; a role per unit build scripts are admitted and receipted; proc-macros are host units native linkage, carriers, cross compilation RFC 119 Resolver registry indexes, version and toolchain requirements never executes package code RFC 117 · OFFLINE AND LOCKED RFC 020 SDK components and compiled providers stdlib as components, package features RFC 114 Cargo compatibility mode explicit adoption only, never silent authority RFC 119 Compiler service (Incan facet) checked analysis; canonical symbol identity executable representation of exports interop: Rust-hosted caller, typed C ABI RFC 120 · 106 · 123 · 097 · 116 · 121 Direct rustc executor compiles units; seals Loaves decides reuse by identity Oven Alpha today RFC 119 The Loaf one sealed *.loaf unit payload · plan identity · receipt RFC 117 · 124 · 125 Store Loaves keyed by unit identity external identity bounds who rebakes (see RFC 124) shared across projects; collected by reach two-instance refusal at plan time RFC 124 · CRASH-SAFE RFC 112 Outputs binaries · carriers LINKED, NOT COPIED Artifact graph cards, relationships, discovery, advisories AI assets: models, prompts, evals, agents a projection of the event log RFC 079 · 080 incan.pub signed source Loaves + attested baked assets; assets are optional sparse index; scoped names; append-only signed events registry identity is a key, hostnames are transport; trusted publishing RFC 125 · SUPERSEDES RFC 034 Mirrors and private registries same protocol, own key STATIC COPY · SAME SIGNATURES crates.io consumed, never published to or mirrored EXTERNAL · SPARSE INDEX, SOURCE ARCHIVES incan check · fmt · lsp · inspect · explain — language and semantic tooling uses the compiler service directly; delegates lifecycle to the Oven API NEVER A SECOND RESOLVER · NO incan bake oven init · add · lock · plan · bake · build · test · publish · yank · store drives resolver, unit graph, executor, store, registry client NEVER INVOKES THE incan CLI LEGEND implemented planned draft in PR #1477 — RFC 124, RFC 125 external or legacy consumed as source only optional / passive the Loaf — the unit Oven bakes, stores, reuses, and exchanges
The map. Facets select units and the manifest is resolved into a lock; the unit graph gives every unit an identity before anything compiles. The compiler service checks the Incan facet and emits Rust; the executor compiles each unit and seals it as a Loaf; the store keeps Loaves by identity and hands them back to any later plan that matches. Publication ships the source Loaf with its attested baked assets, and incan.pub admits an asset back only on exact unit identity. Cargo appears only on an explicit legacy path; crates.io is consumed as source and never mirrored.

Inside a Loaf

A Loaf is not a cache guess. Its identity binds the semantic digest of its source, the dependency lock, the compiler and SDK, the target, the profile, and the resolved features, and its payload carries the compiled Rust library and the checked public surface; the executable representation of its exports (RFC 123) travels with the published source Loaf. A consumer either matches the sealed identity and reuses the result without Cargo, or receives a refusal that names the fact that differs and bakes only what is missing.

Inside a Loaf A Loaf cut open into four layers: an identity over the effective compilation inputs, a payload holding the compiled Rust library and checked metadata, the direct rustc plan that produced it, and the receipt that explains it; when published it also carries publisher and registry attestations. Beside it, a consumer's requested environment is compared with the sealed identity: a match reuses the Loaf without Cargo, a miss is a precise refusal that bakes only the missing units. Inside a Loaf LOCKED, OBSERVABLE ARTIFACT FORMAT · ONE FILE, FOUR THINGS Identity WHAT MADE IT a digest over the effective inputs: semantic digest of the source, dependency lock, compiler and SDK, target, profile, features, provider receipts same inputs on any machine, same identity — that is what makes reuse safe Payload WHAT IT IS compiled Rust library: rlib and rmeta checked .incnlib metadata: the public surface by canonical identity the RFC 123 executable representation travels in the source Loaf, not in the baked unit provider sidecars when the unit is a build script or a proc-macro host Plan HOW TO REPLAY IT the exact direct rustc invocation that produced the payload replayable without Cargo; inspectable with oven store inspect Receipt WHY IT EXISTS inputs, decisions, backend selection, and what may reuse the result one receipt answers “why does this artifact exist?” Attestation added when published: the publisher's signature and the registry's (RFC 125) verified on import; the registry is a key, hostnames are transport WHEN A CONSUMER BUILDS, RUNS, OR TESTS The requested environment its own source, lock, compiler, SDK, target, profile, features IDENTITY Compare with the sealed identity no guessing that yesterday's artifact is probably fine MATCH MISS Reuse link the sealed result no Cargo, no recompilation from this machine's store or imported from incan.pub the receipt says why reuse was allowed Precise refusal names the fact that differs: toolchain, target, profile, features, lock, or source then bakes only the missing units everything that still matches is reused
Four things in one file. Identity says what made it, the payload is what it is, the plan says how to replay it, and the receipt says why it exists. RFC 117 defines the asset, RFC 124 the identity, and RFC 125 the attestations a published Loaf gains; RFC 123's executable representation is carried by the source Loaf.

Where each box is specified

Component Status RFCs
Incan facet implemented RFC 077, RFC 113
Rust facet planned RFC 119; legacy crate dependencies RFC 013
loaf.toml and oven.lock implemented: the manifest and lock names, the incan.toml refusal, and an ignored Cargo.toml; the rest of RFC 117 is planned RFC 117; lock semantics RFC 020
Project lifecycle draft, v0.6 slice 7 for RFC 073, 076, 078 RFC 073, 074, 075, 076, 078
Unit graph and host providers planned RFC 119
Resolver planned RFC 117; offline and locked builds RFC 020
SDK components and compiled providers implemented RFC 114
Cargo compatibility mode planned, explicit adoption only RFC 119
Compiler service implemented, extended by planned RFCs RFC 120, 106, 123, 097, 116, 121
Direct rustc executor Oven Alpha today; planned scope in RFC 119 RFC 119
The Loaf Oven Alpha today; identity in review RFC 117, RFC 124, RFC 123
Store Oven Alpha today; unit identity in review RFC 124; crash-safe publication RFC 112
Outputs implemented RFC 117
Artifact graph draft RFC 079, RFC 080
incan.pub draft, in review RFC 125, supersedes RFC 034
Mirrors and private registries draft, in review RFC 125
crates.io external, consumed as source only RFC 119, RFC 125
Command surfaces incan and oven planned RFC 118

The positioning behind the registry tier is in Ship the loaf, not the recipe; the toolchain that produces the Loaves is in A Cargo-free toolchain for Incan and Rust; what ships today is on the Oven Alpha page.