Assemblies

An Assembly is a thread that can contain other threads. Use one to model anything built from parts — an engine holding its components, a kit holding its contents, a machine holding its installed modules. The assembly is still a full thread: it has its own name, fields, files, identifiers, and history, plus a list of attached Threads.

Attached threads remain independent threads. Attaching doesn’t merge or copy anything — each part keeps its own record, and you can open it, edit it, or detach it at any time.

An assembly thread's detail page with an Assembly card listing its two attached part threads — An assembly is a thread with parts: the Assembly card lists the attached threads, positions, and the rolled-up BOM.

Turn a thread into an assembly

Any thread you own can become an assembly:

Open the thread.
Open the “⋯” overflow menu in the top right (labeled More actions).
Choose Convert to Assembly.

The thread now shows an Assembly badge and gains the attachment tools described below. Nothing else about it changes.

To convert an assembly back, choose Convert to Thread from the same menu. This is only allowed once the assembly is empty — the menu item stays visible but disabled with the reason inline (for example Detach 2 attached Threads and clear 1 position first) until you detach all attached threads and clear all named positions.

Attach and detach threads

From the assembly’s detail page:

Click Attach Thread.
In the Attach a Thread dialog, select one or more threads your team owns.
Click Attach selected.

An assembly can contain other assemblies — nested ones appear with a Sub-assembly badge, so you can model multi-level structures.

To remove a part, open the attachment’s actions menu and choose Detach Thread (or Detach Assembly). Detaching does not delete anything: the thread is removed from the assembly, keeps its own access, and remains in your workspace. If the thread was assigned to named positions, detaching clears those position references — the confirmation dialog tells you how many.

Each attached thread also gains a Part of section on its own detail page, showing the parent assembly it is installed in — outside its own contents.

Positions

Positions are named slots that say where each part goes — Left rotor, Slot A, a role, a location. They’re optional: attach threads first, then assign positions when location matters.

Add position creates a named slot. A position can exist without a thread (“Unassigned”) until one is assigned.
Each position can point at one attached thread (its Linked Thread). Assign one when creating the position, or later with Assign a Thread.
The same thread may be assigned to more than one position — the dialog warns you when you’re about to do that, so duplicates are deliberate.
Use Edit position to rename a slot and Clear assignment to empty it without deleting the position.

The assembly card on the thread page has three tabs: Threads (the flat attachment list), Positions (the named slots and what fills them), and Hierarchy (the nested tree).

Protected attachments

By default, people who can see the assembly can also see its attached threads through it (see access inheritance below). When a part is sensitive, protect it:

From the attachment’s actions menu, choose Protect attachment. The row shows a Protected attachment badge.
A protected attachment stays in the assembly but does not inherit the assembly’s access — sharing the assembly won’t expose it. People with access to the assembly can’t see the protected part through that attachment.
Choose Remove protection to make it inherit access again.

The Assemblies page

The Assemblies entry in the navigation opens a workspace-wide explorer: “Explore your Assemblies, attached Threads, nested Assemblies, and full attachment trees.” Pick an assembly from the All assemblies list, then browse its Attached Threads or its Full tree.

Rolled-up tree and graph

For deep structures, the Full tree view rolls up every attachment, recursively through sub-assemblies. Switch between:

Tree view — an expandable/collapsible outline of the whole structure.
Graph view — a containment graph. Use Expand graph for a full-screen version: drag to pan, scroll to zoom, and click an attached thread to open it.

Each node shows summary counts for the part’s fields, files, and identifiers. Very large trees are truncated to the first attachments with a warning, and parts you don’t have access to are simply not shown (“No visible attached Threads”).

Sharing an assembly shares its contents by default: teams and users you grant access to can see the attached threads through the assembly, without a separate share per part. Two consequences worth knowing:

Detaching can remove access. If someone could see a part only through the assembly, detaching that part takes their visibility with it — the detach confirmation calls this out.
Protected attachments never inherit. Use protection for parts that must not travel with the assembly’s access.

See Sharing and threads for how thread access works in general.

Assemblies and shipments

When you add an assembly to a shipment, its parts go with it — the shipment composer shows a Parts panel where you can review the whole tree and exclude parts:

“Excluding a part leaves out everything installed in it. Excluded parts stay with your team and can be transferred separately.”
A thread that is listed in the shipment on its own and inside an assembly transfers only once — the receiving team gets one copy.
Parts that were already shipped in a previous shipment can’t ship again. The composer asks you to resolve each one: detach it from the assembly (permanent) or skip it (it stays attached, this shipment just won’t include it).

After a source thread has been shipped, DICE also warns you before attaching, detaching, or assigning it inside an assembly — those edits change only your team’s source-side assembly record and have no effect on the recipient’s copy.

See Shipments for the full transfer flow.

Importing an assembly package

Import package on the Assemblies page (or /app/assemblies/import) accepts an Assembly Import Package — a JSON file describing threads, assemblies, attachments, and links. The package is validated into a plan first: nothing is written until you click Commit import, and the import is all-or-nothing. The plan preview shows exactly what will be created or reused, plus any blocking issues to resolve.

For other ways to bring data in, see Importing.

Was this page helpful? Report an issue or suggest an improvement.