Open sourceVersioned physics

A versioned map of physics.

Typed quantities as nodes, executable formulas as edges, every element content-addressed, every change logged. Simulations and measurements attach as values and reconcile at the observables. This is the semantic layer AI needs: fuzzy language in, checkable identity out. Open source end to end: map data CC BY 4.0, code Apache 2.0, and a contribution stays its author's.

Explore the map Read the document
1
·
Nodes
·
Operators
·
Representations
·
Values
·
Version
01Structure

Codes and theory add the graph

Each physical quantity is a typed node; each symbolic formula is an edge that produces one quantity from others. Codes declare how their outputs map onto the shared layer, units and conventions included.

02Evidence

Runs and measurements attach values

Simulation outputs and experimental measurements attach to the same nodes as values. Where several land on one observable, they reconcile there, so agreement and disagreement are both visible and auditable.

03Protocol

Content-addressed, log-first, gated

Every node, edge, and value is content-addressed by a hash. Changes append to a log behind validation gates, so the whole store has an identity and a history you can check.

genesise6e8044e9203
Open sourceWhy the map is open
01Verifiable, not trusted

Anyone can rerun the checks

Every identity here is a content hash and the dimensional layer is proven in Lean. Those guarantees are worth something because anyone can recompute them: clone the repository, rerun the gates, rebuild the proofs. A closed map would be back to trust us.

02Yours stays yours

The license in is the license out

Contributing grants a non-exclusive license, never a transfer: no copyright assignment, no CLA. Map data is CC BY 4.0, code is Apache 2.0, and the rules are public in GOVERNANCE.

03Infrastructure

A commons no one can take away

Agents ground fuzzy language into checkable identities on this map, and nothing durable is built on a foundation someone can revoke. The map is forkable the way git is; that permanence is what lets it become infrastructure. The protocol is the commons; products come after, on top.

The project
IThe commons

The map belongs to everyone

The versioned map, its evidence, and the rules that govern changes are stewarded by OpenMaterials-AI, an open initiative structured as a foundation in formation. Data is CC BY 4.0, the kernel is Apache 2.0, and the stated goal is that no single company owns the commons. Evidence stays its owner's: contributing grants a non-exclusive license, never a transfer; raw simulation and experimental artifacts are never ingested; and upstream codes and papers are credited as a merge gate, not a courtesy. Read the governance.

IIThe interfaces

Views and tools, built on top

The map views, the tracer, the learn pipeline, and the bibliography tooling are built by Da Vinci Labs. Interfaces come and go; the map they render outlives them.

IIIThe engine

AI that grows the map, behind gates

Papers and codebases are machine-read into proposals: verbatim quotes, page anchors, adversarial review. Nothing enters the map without passing the gates and a human. The engine accelerates; the protocol decides.

See it
The playground Type a method in plain language and watch it resolve to typed nodes, or trace a derivation between any two quantities. Fuzzy language in, checkable identity out. The map The whole graph in tiers: pan, zoom, open any quantity for its formula, producing routes, and code coverage. The map in 3D The same graph as a rotating structure: nodes by type, edges for dependencies, height for tier. Orbit it, then tap a node to trace everything upstream. The tracer Pick any quantity and follow one derivation path through the graph, upstream to its sources and down to what it produces. The lineage tour One QHGK result, three layers on one page: the derivation DAG with a learned shortcut, the lineage record that pins the run, and the URL each layer answers to. The experiments A lineage is the shareable run record for an experiment, pinned to a map version. Open one, copy the URL, and share the result. Cross-code agreement Where the map's values agree: the same observable, material, and conditions, produced by a different method or code. The spread is a real method or code disagreement, never an apples-to-oranges artifact. The verified layer The dimensional layer of the map, proven in Lean 4: each node a physics dimension, each executable edge a theorem checked against physlib, with honest coverage counts and links to every generated source. Learn a paper Drop a PDF and map its reported quantities onto the graph, each value backed by a verbatim quote. Runs on the project key behind a cost-gated relay. The guide Install, resolve a label, load the map, parse a paper: the task-oriented developer guide, with every code snippet executed in CI.
Contribute a value

A value is a small JSON file

A recorded value names a quantity, a material, the number with its units, and where it came from.

01Write the instance file (the shape on the right).
02Add it under docs/data/instances/ and open a pull request.
03The gates validate it against the graph; on merge, the store version advances.

The document appendices cover ingesting a new code and extending the DAG (when to add a node versus a parameter).

instance.json
// si-thermalconductivity-bte-solver-rta-kaldo.json (committed, verbatim)
// material + conditions = the configuration of this one evaluation
{
  "variable": "ThermalConductivity[bte_solver=rta]",
  "material": "Si",
  "conditions": {
    "T": 300,
    "mesh": "8x8x8",
    "potential": "Si.tersoff"
  },
  "value": 19.46,
  "units": "W/(m K)",
  "uncertainty": null,
  "source": {
    "kind": "simulation",
    "ref": "kaldo",
    "detail": "RTA; Tersoff; 8x8x8 mesh (cross-code meaningful, absolute under-converged)"
  }
}