Core concepts
DICE connects physical objects to trusted digital records. Everything in the platform hangs off one idea: each physical item gets exactly one digital record, called a Thread, and a physical Identifier on the item ties the two together. The rest of the vocabulary — Folders, Categories, Assemblies, Connections, Shipments, Fabric, Disclosures — describes what you do with Threads: how you organize them, how you work on them with other teams, and how their history survives as they move between organizations.
This page gives you the whole map. Each section links to the full guide for that area.
One item, one Thread
Section titled “One item, one Thread”A Thread is the digital record for one physical item — a part, a lot, a serialized unit, a finished product. It holds:
- Fields — typed data (text, numbers, dates, files, and more), kept consistent across similar items by Templates.
- Files — documents, images, and other media.
- Identifiers — the physical marks bound to the item.
- Transaction history — every event that ever happened to the Thread, permanently.
The physical link comes from Identifiers: a DUST mark, QR code, barcode, data matrix, or NFC tag bound to the Thread. Scanning an identifier resolves back to its Thread — that’s how you identify an unknown item or verify an item is what it claims to be.
Threads belong to a team within your organization. Teams scope everything: ownership, visibility, and permissions.
Organizing Threads
Section titled “Organizing Threads”Three structures organize Threads, and they answer different questions:
| Structure | Question it answers | Shape |
|---|---|---|
| Folder | Where does this Thread live? | Each Thread has exactly one home folder. Folders nest. |
| Categories | What kinds of thing is it? | A Thread can carry any number of category labels. |
| Assembly | What is it physically built from? | An Assembly is itself a Thread whose parts are other Threads — a bill of materials. |
Relationships cover everything looser: free-form links between related Threads, like a part and its batch record.
Working with other teams
Section titled “Working with other teams”Cross-organization work starts with a Connection — the standing channel between your team and a team in another organization. A Connection has a lifecycle and a direction (send, receive, or both) that governs everything flowing between the two teams.
Over a Connection, there are two very different ways to give another team your data — this is the distinction that trips up most new users:
- Sharing grants live access to the Thread you own. There is one record; the other team views or edits it in place; you can revoke the share at any time.
- Shipments transfer a copy. You choose exactly which fields, files, and identifiers travel; the receiving team reviews the shipment and, on acceptance, gets their own Threads. Your originals stay behind, marked Shipped.
Rule of thumb: share to collaborate, ship to hand over.
Provenance: where things came from
Section titled “Provenance: where things came from”When items physically move or change hands, their history shouldn’t evaporate. Three features keep it:
- Slicing derives new Threads from an existing one within your team — cutting rods from a bar, splitting a lot into serialized units. The source is unchanged; the derivation is recorded.
- Fabric is the lineage graph those derivations build. Every shipment and every slice leaves a permanent link, so a Thread can be traced upstream to its origins and downstream to everything made from it — across organizations, independent of whether you are still connected.
- Disclosures control what travels along that graph afterward. Transferred copies are snapshots; when a source team wants downstream holders to see new or corrected data, it explicitly pushes a disclosure, and every downstream team can review and adopt it. What is withheld simply never appears.
Certificates round this out: immutable, point-in-time PDFs generated from a Thread’s data, for when provenance needs to leave the platform entirely.