AI Infrastructure Foundations

Choose the audience that matches your question

The page contains three selectable readings of the same subject.

    return Err(SessionExpired);

Deterministic fixed-point arithmetic with identical bits on every supported machine.

Parses source material into content-addressed trees whose origin can be verified by hash.

Retrieves exact matches from binary hyperdimensional indexes on ordinary CPUs.

Compiles policies once, then evaluates them on the hot path without a service round-trip.

Folds an event log into any past state so simulations and decisions can be replayed.

Runs FMI 3.0 models deterministically across supported simulation backends.

Packages an AI decision with a reasoning certificate that can be checked offline.

Keeps append-only, hash-chained event provenance without quiet history edits.

Signs agent events and folds them into a replayable run record.

Records what happened inside a sandbox, not merely that the process was contained.

Serialises model data densely without carrying JSON syntax through every token.

Reads and writes seventeen office document formats through one Rust interface.

Turns a recurring source question into typed records with the collection route attached.

Compresses prompts by fixed published rules inside the process that already holds the text.

Gives agents and designers one typed interface for a web-native game world.

Searches for program optimizations from a specification and turns the result into executable code.

Studies artificial-life systems in which local signals produce adaptive collective behaviour.

Open the project to see its mechanism, interfaces, and place in the stack.

Fourteen Apache-2.0 open-source foundations and three adjacent research programmes. HEDL is public now. The remaining repositories publish in fortnightly rounds from 1 September 2026, two at a time to begin with, so each one gets read rather than buried.

Gather the relevant source material under one recorded route.

Parse the material into stable, content-addressed structure.

Retrieve the exact evidence needed for the current question.

Evaluate the policy that governs what the system may do next.

Bind the decision to a checkable reasoning certificate.

Sign the agent events and preserve the run for replay.

The user sees the answer; the route, evidence, policy, proof, and event record remain attached underneath.

The projects are not a bag of utilities. Each owns one boundary in the work: source intake, structure, retrieval, policy, proof, or event history. Operations can inspect the handoff where a result changed instead of reconstructing one opaque application. Every handoff names the project answerable for it, so a review starts at that step rather than at the whole route, and the run record at the end points back through each one.

A useful composition path starts with source intake and ends with a signed event record. Each project narrows one concern and passes an explicit artefact forward, so retrieval, policy, proof, and replay can evolve without collapsing into one runtime. The census records verified scope rather than an automatic chain, so an edge exists here only where a project states it, and every other pairing stays a selection you make.

Sources and parsed structures remain attached to the run.

Retrieval, policy, and reasoning each leave their own output.

The final run record points back through every handoff.

Fabric is the workspace you use. Underneath it, focused parts gather the right material, organise it, find what matters, check the rules, explain the decision, and remember what happened. You do not operate any of them separately. The result comes back in one place, and the trail behind it stays available whenever you want to look at it. There is nothing extra for you to install, update or manage.

Fabric receives the question in the workspace you already use.

They gather, organise, find, check, explain, and record.

The answer is clear, while its supporting trail remains available.

Jacquard, Forge and Mycelia, kept adjacent

HEDL is public, the rest publish in rounds

All fourteen foundations use Apache-2.0; each project keeps its own scope, release record and evidence.

The parts hand results forward; you never operate them separately.

Open a project page to understand one mechanism in depth, or use Fabric to experience the complete route as one workspace.

Fabric presents the result while the focused parts work underneath.

The projects hand explicit results forward instead of hiding the work in one runtime.

Each project owns one narrow technical responsibility.

Fabric is the workspace you use. Underneath it, fourteen Apache-2.0 open-source foundations each own one narrow task. HEDL is public now; the rest publish in fortnightly rounds from 1 September 2026. Jacquard, Forge, and Mycelia sit alongside that route as three separately scoped research tracks, not as parts of the workspace you open.

14 source-available foundations + 3 research tracks

Fabric is the workspace you use. Underneath it, fourteen source-available foundations each own one specific part of the route: they gather, organise, retrieve, check, explain, and record, without asking you to manage any of them separately.

Fourteen foundations and three adjacent research tracks, grouped by architectural job. Open any name to see its mechanism.

Each project page explains its mechanism, interfaces, and evidence. Start with the capability you need, then follow how it composes with the rest of the stack.

Map one responsibility and its handoffs, or see how the complete stack is deployed and operated inside your environment.

Measured on a desktop i9, AVX2, no GPU. Exact recall held at 10K documents. The suites ship with the repos.

test replay::bit_identical_across_isa ... ok

test rounding::correctly_rounded_all_kernels ... ok

lookup/hot_path time: [1.36 ns 1.36 ns 1.37 ns]

Hybrid-MultiQ D4096 random 10K 1.0000 35,842 116.8

Index N Recall QPS P50(us)

cargo run --release --example comprehensive_benchmark

Determinism is checked by the suite, not merely promised in prose.

Read it beside the evidence point in the census.

Use the project command on hardware you control.

Start with BitWeave, Lattice, or Numerus, where a measured route is already named.

A benchmark matters only when the command behind it is clear. Choose a measured route, run the same mechanism on hardware you control, compare the result with the census, then rerun the tests that guard determinism. BitWeave, Lattice, and Numerus already name a measured route, so start at one of those rather than building a harness of your own.

Fourteen foundation paths + three research routes

What the project page states, or a pointer to the repo where it is still settling.

crates.io where it is live today, and with its round where it is not. Stated plainly.

One reproducible result where a headline measurement is useful.

The responsibility this project owns in the composed stack.

Each project owns one narrow architectural job. Read its role, inspect the evidence point where one is useful, then open the project to follow the mechanism and interfaces in depth.

The census maps source intake, mathematics, policy, proof, event history, and data handling to one accountable project each. When a result changes, teams can locate the responsible handoff instead of auditing one opaque application.

Source intake, mathematics, policy, proof, event history, and document handling do not disappear inside one platform. Each has a focused project and an explicit handoff, so operations can locate the owner of a result, inspect the evidence, and change one layer without replacing the whole route.

Fourteen foundations each own one architectural job, interface, and evidence trail. Three adjacent research tracks remain separately scoped. Use the census to find a responsibility, follow the composition route to see foundation handoffs, then reproduce a measured behaviour where a headline result is useful.

Fourteen foundations, one role each; three adjacent research tracks are listed separately. Measurements appear only where a reproducible headline result helps explain the mechanism. Open any row to follow its interfaces, behaviour, and place in the composed foundation stack.

79.2% vs 65.0% on 571 questions · 6,981 vs 15,771 prompt tokens (one model/setup; v1.3, Feb 2026)

1.36 ns hot path (referenced CPU benchmark; run on your hardware)

9,473 QPS exact multi-query · recall 1.000 · DBpedia 100K/19 MB · i9-13900KF AVX2/48 GB (benchmark receipt)

How one accountable operation crosses the Dweve product stack

Keep AI work and company records in their proper lifecycle.

Ground the work, then produce a traceable result.

Turn the objective into governed tasks and operator-visible action.

Run the selected work on declared infrastructure.

The business receives one reviewable return, not a collection of disconnected system logs.

Responsibility stays with the operation from brief to return.

Policy and approval remain explicit at every handoff.

The result rejoins its evidence and decisions before it returns.

Typed contracts through the Dweve product stack

A separate graph-native systems product, available when that route is selected.