Core concepts
Start with one object on a bench — a turbine blade, a bar of alloy, a finished watch. DICE gives that object a physical Identifier and a digital record called a Thread, and keeps the two tied together for the rest of the object’s life.
Read this diagram as text
- A physical item — a part, a bottle, a label — carries an Identifier.
- An Identifier is a DUST mark, a QR code, a barcode or an NFC chip.
- Scanning the Identifier resolves to a Thread, the item's record in DICE.
Scan the Identifier and you get the Thread. That is the whole idea; everything else on this page is something you can do once it is true.
One item, one Thread
Section titled “One item, one Thread”A Thread is the digital record for exactly 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 log — every event that ever happened to the Thread, permanently.
The physical link comes from Identifiers: a DUST marking, QR code, barcode, data matrix, or NFC tag bound to the Thread. Scanning one resolves back to its Thread — that is how you identify an unknown item, or verify that an item is what it claims to be.
Your organization and Team
Section titled “Your organization and Team”Every Thread belongs to a Team, and every Team belongs to an organization. That pairing is your context, and it is the unit everything else is measured against: ownership, visibility, and permissions all follow the Team.
You pick your context when you sign in and can switch it at any time from the top bar. Switching changes what every page shows — a Thread that belongs to another Team simply isn’t there until you switch to it. See Getting started.
Organizing Threads
Section titled “Organizing Threads”Once you have more than a handful of Threads, three structures give them shape, 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, and this is the distinction that trips up most new users:
Read this comparison as text
- Share — live access. You grant a partner Team access to your Thread and ownership stays with you. There is one Thread, so everyone sees the live record. Each Team gets a Viewer or Editor role. A share is revocable: you can unshare at any time.
- Ship — transfers a copy. You send a copy to another organization and they own it. The receiving Team gets a new Thread containing a snapshot of the fields, files and Identifiers you chose. The transfer is recorded in Fabric, and your original Thread stays in place, marked Shipped.
- 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 its 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.
The whole map
Section titled “The whole map”If you prefer to see the vocabulary all at once, this map shows how every term above relates. It is an optional overview — you never need to hold all of it in your head to use DICE.
Read the whole map as text
- Physical world: a physical item carries a DUST Identifier — a QR code, barcode or NFC chip works the same way. Scanning the Identifier resolves to a Thread.
- The core record: a Thread is one item's digital record. It holds typed fields, files, the Identifiers bound to it, and a permanent history of every event.
- Organize: a Thread lives in exactly one Folder, is sorted into any number of Categories, and can be installed in an Assembly, whose parts are Threads too.
- Collaborate: a Thread is owned by your Team, inside your Organization. Over a Connection with a partner Team, you can Share it — live access, ownership stays with you, revocable — or Ship it, which sends a snapshot copy the receiver owns.
- Provenance: a source Thread in a partner organization Transfers to your Thread; your Thread can be Sliced into a new derived Thread in the same team. Fabric records every Transfer and Slice as a permanent lineage graph, and Disclosures push chosen data down the whole chain.