UORustby UOR Foundation Try it in your browser

// Your Verifiable Agentic Foundation

UORust

UORust reads any Cargo workspace and writes a full Prism model of it, with every facet.

Every kind of Rust fact becomes exactly one kind of Prism record, or is refused. Twenty-eight routes cover crates, dependencies, public functions, tests, error and state enums, unsafe code, file, network, process and environment use, lock-file packages, lints and benchmarks. Two kinds that name different routes are refused as ambiguous, never resolved by a default.

Try the route tableLearn UORustSourceReleases
What a rust developer does with UORust1. Project workspace: Write the projection of a workspace into a directory. 2. Checked output: The gate checks the committed fixture projection and a fresh projection of this workspace with lexlean and prismpm 3. Deterministic output: Two projections of the same workspace are byte-identical, for the fixture and for this workspace 4. Check projection: Check that a directory holds exactly the projection of a workspace.01ProjectworkspaceWrite theprojection of aworkspace into adirectory.02Checked outputThe gate checksthe committedfixture projectionand a freshprojection of thisworkspace withlexlean andprismpm03DeterministicoutputTwo projections ofthe same workspacearebyte-identical,for the fixtureand for thisworkspace04Check projectionCheck that adirectory holdsexactly theprojection of aworkspace.What a rust developer does with UORust1. Project workspace: Write the projection of a workspace into a directory. 2. Checked output: The gate checks the committed fixture projection and a fresh projection of this workspace with lexlean and prismpm 3. Deterministic output: Two projections of the same workspace are byte-identical, for the fixture and for this workspace 4. Check projection: Check that a directory holds exactly the projection of a workspace.01Project workspaceWrite the projection of aworkspace into a directory.02Checked outputThe gate checks the committedfixture projection and a freshprojection of this workspace withlexlean and prismpm03Deterministic outputTwo projections of the sameworkspace are byte-identical, forthe fixture and for thisworkspace04Check projectionCheck that a directory holdsexactly the projection of aworkspace.
What a rust developer does with UORust. The tasks of the first user group's goal, in order. Each one is a feature of UORust with acceptance tests.
The data in this figure
StepWhat happens
1. Project workspaceWrite the projection of a workspace into a directory.
2. Checked outputThe gate checks the committed fixture projection and a fresh projection of this workspace with lexlean and prismpm
3. Deterministic outputTwo projections of the same workspace are byte-identical, for the fixture and for this workspace
4. Check projectionCheck that a directory holds exactly the projection of a workspace.

// Context of use · ISO 9241-11

Who it is for

Every user group of UORust, the goal each one comes for, and the tasks that get it done, in order. Each task is a feature with acceptance tests. The guides below speak for each group.

Who it is for 5 items
  • Rust developerCheck that a directory holds exactly the projection of a workspace.Owns a Cargo workspace and runs uorust to get a Prism model of it without writing the model by hand.
    • 1. Project workspace
    • 2. Checked output
    • 3. Deterministic output
    • 4. Check projection
  • Prism modelerThe gate checks the committed fixture projection and a fresh projection of this workspace with lexlean and prismpmReads, checks and extends the Prism project uorust emits, and relies on every record tracing to a source span.
    • 1. Route facts
    • 2. Refuse ambiguity
    • 3. Lift behavior
    • 4. Checked output
  • Security reviewerEvery way a run can end without a projection is a typed UorustError variant with a negative testReviews the threat model uorust derives from unsafe code, effects and the supply chain, and the controls that answer it.
    • 1. Project workspace
    • 2. Refuse ambiguity
    • 3. Typed errors
  • DevRel authorUORust is modeled in every facet, each with records, and every module title has a project-local glossary entryWrites the walkthroughs and explorers that teach UORust, and covers every facet record with a resource.
    • 1. Browser routes
    • 2. Route facts
    • 3. Self model
  • MaintainerCheck that a directory holds exactly the projection of a workspace.Changes the route table, the engine and this model, and keeps the Rust router, the verified table and the Pages site in step.
    • 1. Self model
    • 2. Route facts
    • 3. Deterministic output
    • 4. Check projection

// Command line

Run it

What UORust's command line answers, read from the features that call it.

// Architecture · ISO/IEC/IEEE 42010

How it works

The components of UORust and the systems it works with.

How the parts of UORust connect14 nodes and 20 links. Subject workspace to Ingest; Cargo to Ingest; Subject workspace to Cargo; crates.io to Cargo; uorust CLI to Ingest; Ingest to Router; Router to Admission; Admission to Emitter; Emitter to uorust CLI; Emitter to PrismPM SDK; rustc toolchain to uorust CLI; crates.io to uorust CLI; Router to Route-table guest; Route CLI adapter to Route-table guest; Route-table guest to Route CLI adapter; Pages site to Route-table guest; Route-table guest to Pages site; PrismPM SDK to Route-table guest; GitHub Actions to Pages site; GitHub Actions to uorust CLI.AdmissionCargouorust CLIcrates.ioEmitterGitHubActionsIngestPages sitePrismPM SDKRoute CLIadapterRoute-tableguestRouterrustctoolchainSubjectworkspaceHow the parts of UORust connect14 nodes and 20 links. Subject workspace to Ingest; Cargo to Ingest; Subject workspace to Cargo; crates.io to Cargo; uorust CLI to Ingest; Ingest to Router; Router to Admission; Admission to Emitter; Emitter to uorust CLI; Emitter to PrismPM SDK; rustc toolchain to uorust CLI; crates.io to uorust CLI; Router to Route-table guest; Route CLI adapter to Route-table guest; Route-table guest to Route CLI adapter; Pages site to Route-table guest; Route-table guest to Pages site; PrismPM SDK to Route-table guest; GitHub Actions to Pages site; GitHub Actions to uorust CLI.Admissioncrates.ioSubject workspaceGitHub Actionsrustc toolchainEmitterCargouorust CLIPrismPM SDKIngestRouterRoute-table guestPages siteRoute CLI adapter
How the parts of UORust connect. Each box is a component, coloured by its kind. Each arrow is an edge of the architecture: data or control moving from one part to another.
The data in this figure
FromLinkTo
Subject workspace→Ingest
Cargo→Ingest
Subject workspace→Cargo
crates.io→Cargo
uorust CLI→Ingest
Ingest→Router
Router→Admission
Admission→Emitter
Emitter→uorust CLI
Emitter→PrismPM SDK
rustc toolchain→uorust CLI
crates.io→uorust CLI
Router→Route-table guest
Route CLI adapter→Route-table guest
Route-table guest→Route CLI adapter
Pages site→Route-table guest
Route-table guest→Pages site
PrismPM SDK→Route-table guest
GitHub Actions→Pages site
GitHub Actions→uorust CLI
How it works 14 rows
ComponentKindWhat it does
uorust CLIRelease binaryProject any Cargo workspace into a complete, checked Prism project.
IngestServiceIngest: cargo metadata, the manifests, Cargo.lock and every source file, parsed with syn, into facts with spans.
RouterServiceThe route table and the router: which kind of Rust fact becomes which kind of Prism record in which facet.
AdmissionServiceAdmission: what the router proposes is admitted, or refused with a typed reason that becomes an open claim.
EmitterServiceProjection: admitted facts to the files of a Prism project, byte for byte the same for the same workspace.
Route-table guestServiceThe Core-Wasm guest compiled from app/src/Routes.lex.tex: the verified route table, replayed against every acceptance vector.
Route CLI adapterCli adapterThe generated uorust-routes program that answers the same route requests as the page from a file or standard input.
Pages siteStatic siteThe GitHub Pages site that describes UORust and runs the route-table guest in the browser.
Subject workspaceExternal systemThe Cargo workspace uorust reads: manifests, lock file and Rust sources.
CargoExternal systemThe cargo metadata command that resolves the subject workspace's packages, targets and dependencies.
crates.ioExternal systemThe registry the locked dependencies of uorust and of the subject come from.
rustc toolchainExternal systemThe pinned Rust toolchain that compiles uorust with forbid(unsafe_code) and the workspace lints.
PrismPM SDKExternal systemThe locked PrismPM and LexLean SDK that checks the emitted project and verifies this model.
GitHub ActionsExternal systemThe CI that runs just vv on every push and deploys the Pages site.

// Security · ISO/IEC 27034 and 27005

How it is kept safe

11 threats and the 13 controls that answer them. The threat model maps every threat to a control with evidence.

Threats the model namesControls that answer them
Build script execution
Source exfiltration
Crafted source exhaustion
Misrouted fact
Disputed projection
Dependency compromise
Unsafe memory
Path escape
Workflow token abuse
Tampered pages
Pages host substitution
No build execution
Offline
Bounded ingest
Verified route table
Router conformance
Typed refusal
Deterministic output
Cargo deny
Locked build
Forbid unsafe
Confined output
Pinned workflows
Artifact closure

// Quality · ISO/IEC 25010

How it is measured

Each quality measure and the bound it must stay within.

MeasureBound
Routed fact kinds29
Route vectors41
Self model drift0
Rerun differing bytes0
Self projection milliseconds16258
Route request bytes330
Unregistered tests0
Clippy warnings0
Minimum rust minor89
Route cli needed libraries0
Unsafe blocks0
Unlifted functions0

// Brand · Wheeler, W3C design tokens, WCAG 2.2

The brand it carries

Read from UOR Foundation at the commit brand/foundation.lock pins. Every text colour meets its WCAG 2.2 contrast criterion, a theorem the Lean kernel checks.

ElementText
NameUOR Foundation
TaglineYour Verifiable Agentic Foundation
PromiseBuild, ship and run self-verifying AI applications that just work. From edge to cloud, and beyond.
PositioningPrism is an open SDK that seamlessly enables you to build, ship and run self-verifying AI applications. From edge to cloud, and beyond.
MissionUniversal Object Reference (UOR) is an open standard for content–addressed decentralized identity of digital objects. Based on formal verification.
ValueOpen by default
ValueIdentity from content
ValueNo central authority
StewardStewarded by an independent 501(c)(3).
Call to actionnpx prism-code@latest setup
TypographySpace Grotesk, system-ui, sans-serif; JetBrains Mono, ui-monospace, monospace
Product nameUORust
Product promiseEvery kind of Rust fact becomes exactly one kind of Prism record, or is refused.
The brand it carries 7 items
  • --fd-bg#0a0a0a
  • --fd-panel#121212
  • --fd-fg#fafafa
  • --fd-dim#999999
  • --fd-line#333333
  • --fd-line-strong#616161
  • --fd-accent#fafafa
TextOnContrastWCAG 2.2 needs
--fd-accent--fd-bg18.97:14.5:1
--fd-accent--fd-panel17.95:14.5:1
--fd-bg--fd-accent13.62:14.5:1
--fd-bg--fd-fg18.97:14.5:1
--fd-dim--fd-bg6.95:14.5:1
--fd-dim--fd-fg6.04:14.5:1
--fd-dim--fd-panel6.58:14.5:1
--fd-fg--fd-bg18.97:13:1
--fd-fg--fd-bg18.97:14.5:1
--fd-fg--fd-line15.79:14.5:1
--fd-fg--fd-panel17.95:13:1
--fd-fg--fd-panel17.95:14.5:1
Words on this page 11
Prism model
A description of an app, written in LexLean, that covers every facet of it and that the Lean kernel checks before the app is built.
facet
One view of a model, such as its architecture, its security or its quality. Each facet holds records.
record
One entry in a facet: a component, a threat, a measure or a journey step, with the place in the source it came from.
Lean kernel
The small checker at the heart of the Lean prover. It accepts a proof only if every step follows the rules.
theorem
A statement about the model that the Lean kernel has checked, so it holds for every input, not only the ones tested.
lift
To translate a Rust function into a LexLean definition with its proofs, so the model says what the code does.
acceptance test
An input and the output the app must give for it. The holo replays each one before it is offered.
UOR
Universal Object Reference: the UOR Foundation's framework for naming any object by its content.
route table
UORust's table of which kind of Rust fact becomes which kind of Prism record, in which facet.
projection
The Prism project UORust writes for a Cargo workspace: one module per facet, written the same way every time.
Cargo workspace
A set of Rust packages that Cargo builds together, with one lock file.