Skip to content
cairn.

RUST + WEBASSEMBLY DATAFLOW RUNTIME

Cairn.

AI-built applications.
Authority you keep.

Bound the computation. Govern the effects. Recover with evidence.
For private workflows and geo-distributed, high-availability systems.

A private request crosses sealed input, pure WebAssembly, blessed storage and owner-authorized reveal boundaries.

15 SECONDS / A REAL LOCAL RUN, EXPLAINEDOriginal animation. Synthetic input. Not a screen recording or distributed deployment.

SEALED DATA / BOUNDED EXECUTION / GOVERNED EFFECTS / AUDITABLE RECOVERY

A private request.
A useful record.
A controlled reveal.

An intake or CRM application needs to remember a request without scattering private text through its shared history.

We ran the published Cairn CLI with four Rust-built WebAssembly guests and a fresh synthetic store. The request was accepted, a blessed storage node wrote a safe reference, and only an authorized owner could reveal the private body.

Application code transforms data. Cairn’s runtime-owned blessed effect nodes hold the authority to touch storage or the outside world. An AI-authored transform does not receive an unrestricted database password.

  1. 01 / RECEIVE

    Keep the body private.

    The synthetic contact returns a safe receipt. Raw input is absent from public content-addressed storage.

    POST 200
  2. 02 / PERSIST

    Grant a specific effect.

    Pure guest logic connects to blessed storage. Shared application state retains a private-blob reference, not the message.

    1 safe row · 1 effect
  3. 03 / REVEAL

    Check the viewer.

    No session refuses. The authorized owner reveals the body, with an access record that does not retain plaintext.

    401 denied / 200 allowed
EVIDENCE INCLUDES THE LIMIT

The served list query refused with 400 because its required ledger source was absent. The operator’s direct query found one row; that is not a successful served-list request. Five contact-safe surfaces were checked for synthetic private text; the privacy scan reported no findings.

This local run does not exercise distribution, PostgreSQL compensation or external delivery. Those mechanisms have separate source and evidence boundaries.

Where else does the same model fit?

From mechanism to application.

Different jobs. The same separation of computation, authority and evidence.

IMPLEMENTED MECHANISMS / LOCAL FLOW PROOFS

A useful app.
Less exposed data.

Customer intake, internal casework and CRM need useful state, not private text scattered through shared history. Keep sensitive inputs sealed; give each step only the access it needs.

Trace the privacy boundary
  1. 01 / RECEIVESealed input

    Private bytes stay scoped.

  2. 02 / COMPUTEPure transformation

    No ambient database authority.

  3. 03 / PERSISTBlessed storage

    Retain a safe private reference.

  4. 04 / REVEALGoverned access

    Authorize reveal and keep evidence.

Privacy still depends on the application’s reviewed flow. Pure computation does not automatically declassify its outputs.

IMPLEMENTED / MANIFEST-BOUND REVIEW

Generated logic.
Deliberate authority.

An AI can propose application transforms and wiring without receiving a general-purpose host credential. Review the actual graph, capability set and registered cost before promotion.

Follow the application model
  1. 01 / AUTHORPure WASM guests

    Write bounded transformations.

  2. 02 / COMPOSECandidate graph

    Bind the source manifest.

  3. 03 / REVIEWCapability & cost

    Inspect before granting authority.

  4. 04 / PROMOTEReviewed identity

    Deploy the approved coordinate.

Capability review narrows authority; it is not a proof that arbitrary generated application logic is correct.

SEPARATE HOSTED EXPERIMENTS / JULY 2026

Reach the service.
Respect the writer.

Geo-distributed, high-availability applications need more than extra copies. Cairn combines election, lease, writer-fencing and readback components with capacity-aware placement and policy-governed elastic planning.

Read the distributed evidence
  1. 01 / ARRIVERequest ingress

    A request can enter elsewhere.

  2. 02 / ROUTEElected owner

    Forward to the writer.

  3. 03 / AUTHORIZEFenced mutation

    Keep stale writers outside.

  4. 04 / OBSERVEVerified readback

    Check what becomes visible.

Hosted drills are separate evidence. Elastic planning is not an always-running production autoscaler; this is not a durable-before-ACK, whole-region recovery or SLA claim.

RESEARCH APPLICATION / NOT FLIGHT-QUALIFIED

Far from a link.
Not beyond scrutiny.

Remote instruments and redundant workers could share approved observations, inspect the same identified work and keep physical actions behind separate authority. Ground systems could inspect the retained trail later.

Explore the remote-compute case
  1. 01 / CAPTURERecorded observation

    Preserve origin and policy.

  2. 02 / CHECKIndependent compute

    Use a defined execution profile.

  3. 03 / PERMITEffect boundary

    Agreement is not authority.

  4. 04 / RETAINOutcome evidence

    Inspect across a delayed link.

An application pattern to engineer and test, not an implemented voter. Synthetic inputs are not sensor evidence, and matching outputs can share a fault.

Built toward enterprise-grade applications, with inspectable mechanisms rather than a certification claim. Implementation and evidence boundaries

Decide. Verify. Act.

A remote instrument must choose a mode before its link returns. The proposal is not the permission. The write is not the acknowledgement.

LOADING WASMScope & source
Computation sandbox
Scenario

A decision beyond the network.

Resolve the live sensor branch and battery input. Propose a mode in WASM, check it separately, then cross the blessed effect boundary.

READY / 00

Inputs pending.

PENDING / NO EFFECTS

The inputs come before the action.

Rust-compiled kernels run here. The database, observations and network are a session-local simulation.

No computation coordinate yet
New compute fuel
0 work units
Sandbox database
No decision
Delivery pending
0
Pure cache
0 / 24
Forward effect journal 0 EVENTS

No writes or deliveries.

Real WebAssembly and BLAKE3; simulated authority, storage and delivery. Fuel is this kernel’s explicit work-unit count, not Wasmtime instruction fuel or physical propellant. Rewind changes inspection, not the world. No values leave this tab.

What this proves

Auditable work.
Redundant
execution.

On a spacecraft, separate computers may need to cross-check a decision before anything acts. The useful unit is the execution chain: what was observed, which code ran, what it concluded, and what was allowed to change.

Cairn separates observations and effects from pure computation. That creates a foundation for giving redundant workers the same approved, recorded inputs and comparing their work without asking each worker to repeat a physical action.

The same pattern could connect a remote instrument to Earth: send identified work and retained evidence across an intermittent link, then inspect or recompute on arrival. Local authority must not depend on a real-time round trip. These are research applications of the architecture, not a released spacecraft voting system.

The spaceborne case, precisely

Repeat the computation, not the physical action. Recorded observations keep their origin and access policy; synthetic mocks stay synthetic. Agreement is neither sensor truth nor permission to actuate.

CONTENT-ADDRESSED IMMUTABLE REIFY NETWORK

Remember.
Return.
Move forward.

Rewind a versioned state. Compensate supported effects with a new authorized, metered action. Keep the original evidence.

Recovery, without erasure
Content becomes a stone. History becomes a cairn.

Start small.
Keep the evidence.

Build the CLI, run a pure WebAssembly DAG, then repeat it and inspect the cache. No account, provider key or public server is needed.

Cairn and Perffection source are public under AGPL-3.0-only, with documented MIT exceptions and third-party notices. Read the code, run it locally, and build from the evidence.

PINNED RUST TOOLCHAIN · CARGO · LOCAL DISK

TERMINAL / BUILD THE CLI
git clone --branch main_chirho \
  https://github.com/loveJesus/cairn-opensource-chirho.git
cd cairn-opensource-chirho
unset CAIRN_BUILD_COMMIT_CHIRHO
CARGO_INCREMENTAL=0 CARGO_PROFILE_DEV_DEBUG=0 \
  cargo build --locked -j2 \
  -p cairn-cli-chirho -p cairn-tree-build-chirho --bins
target/debug/cairn-chirho --version

For people. For agents. For source readers. Start with the architecture and evidence map, then follow the runtime contracts, app-authoring guide and implementation paths. The browser lab is not the full engine.

Runnable quickstart Technical guide AI reading map
Perffection.

Business software on the same foundation.

Perffection is a separate product built on Cairn. Its application guests, documents and interface evolve in their own repository; the runtime stays generic. Both source snapshots are public, with the product pinned to its exact engine.

Visit the Perffection application

Built to serve.
For the glory of God.

Cairn takes its name from memorial stones: a visible reminder of what happened, and why it matters.

Our deepest hope is not in software. God loves us; we have sinned and need His forgiveness. Jesus Christ died for our sins and rose again. Salvation is His gift, received by grace through faith, not earned by our work. Turn to Him and trust Him.

Read the good news

You are welcome here whether or not you share our faith. The software’s license governs its use.

THOUGHTFUL SYSTEMS. USEFUL SOFTWARE.

Something worth building?

Let’s talk.