Prism is a compiler and runtime for machine-learning models on local hardware. Its single product is the ComputeImage: a sealed artifact that names the decisions made at compile time and binds them to the plan the runtime executes.

The compiler decides representation, layout, target legality, and numerical policy. The decisions are typed operations on the constitutional ECS. They are recorded in a plan. The plan has an identity; re-planning produces a new plan identity and a new admission record.

The runtime is the executor of the plan, not its author. It may not alter semantic, representation, legality, or numerical-policy decisions in an admitted plan. It consults the plan for those decisions and the world for everything else: admission, ownership, leases, deadlines, transaction validity, terminal failure.

A request enters the world through a typed command, is admitted through a transaction, and is recorded as a durable event. The transaction is the only path to canonical state change. The receipt is the only path to authority. The output is not authoritative without the receipt.

A failure is a first-class outcome. It is emitted through the same receipt path, with the same provenance, with a defined failure class. Failure is not a regrettable variant of success; it is part of what the system records.

The vocabulary is closed. There are four capability states — Planned, Implemented, Qualifying, Validated — and two distribution states — Unreleased, Released. The site does not use supported, ready, active, live, or available as status words. Every status word on this site has a definition.

The path starts with motivation, ends with the source. The vocabulary is the same at every step.

• Motivation — the home page's argument, restated. Why Prism exists.
• Architecture — How Prism is organized. The three primary contracts, the compiler as search, the runtime as authority, the plan as the boundary.
• ComputeImage — The artifact the compiler produces. Six inspectable strata, three identities, the receipt, the search history.
• Evidence — What the runtime records. The receipt chain, replay, failure, the corpus.

Each step links to its route. The path does not branch. The path is read in order.

Prism is not an inference runtime with a compiler bolted on. It is a compiler with a runtime built to execute its plans. The distinction is not marketing. The runtime cannot rewrite the plan. The plan is the boundary.

Prism is not a multi-cloud orchestrator. It does not claim universal backend support. The capability map names which targets are implemented, which qualify, and which are still planned. Every row is a source path and a limit. Nothing is inferred.

Prism is not a research toy. The architecture is concrete; the artifacts are inspectable; the receipts are durable. The plan/runtime split is enforced by types, not by convention. The Constitution is read.

Prism is not a finished product. The roadmap contains future work. The status page contains present work. The lab contains exploratory work. The three are not the same.

The home page is the entrance. The primary navigation is Start, Architecture, Evidence, Status, GitHub. Everything else orbits.

The Observatory at /observatory/life/ is the deeper experience. It follows one specimen through the canonical journey. The selection state persists in the URL. The JavaScript-free fallback is the same authored work without synchronization.

The Colophon at /colophon/ is the close. It names the author and the collaboration model. It is the only place on the site that explains who is building Prism and how engagement works.