Layers, stacks & processes

A design is drawn as components, and it is made as a stack of bonded slabs, each formed by a process. This page is the model that connects the two.

The stack

A stack is an ordered list of layers — slabs bonded face to face along one axis. Layer 0 is the one nearest the substrate and the numbers count away from it, so a design anchors at its lowest layer and builds upward.

Each layer carries a thickness; a material, with an optional laminate backing of a second material filling the space below the deepest feature; default face, depth and walls for the features cut into it; and, if you want one, a process of its own that overrides the stack’s.

Between adjacent layers sits a bond, and the bond carries the alignment tolerance of that joint. How those tolerances accumulate is the stack’s registration scheme: Common datum locates every layer against one reference, while Sequential · RSS and Sequential · worst case locate each layer against the one below it and differ in how they add the error up.

Deleting is guarded on both tiers: a stack must keep at least one layer, a design must keep at least one stack, the active stack cannot be deleted, and a layer carrying content has to be emptied first.

Faces, depth and the roof

A feature is not a shape floating inside a slab — it is cut in from one side. Which side is the face, Top or Bottom, and how far in is the depth.

What is left above a feature is the roof, which is thickness − depth. A thin roof is what sags shut in a soft material, so the roof is something the design rules measure rather than a by-product of two other numbers. Where depth reaches the thickness the feature goes all the way through and the layer is open on both faces there.

A channel is an open trough until something covers it. Sealing is the stack’s business: the trough becomes a conduit once the neighbouring layer’s face closes it.

Several stacks, one active

A design carries as many named stacks as you like and fabricates against one active stack. Switching the active stack switches thickness, material, layer count and forming process together, so a prototype target and a production target live in one document.

The base layer is the layer of that stack the design’s root anchors at. It is a design edit rather than a view setting, and the viewport always shows the design at that anchor — so what you see is what fabricates.

Beside it, the active layer is view state: it is where a newly placed child lands, and which layer is drawn vividly against the muted rest. Changing it edits nothing.

Processes

A process is how one layer is formed. Processes live in a shared pool: each stack names one as the default its layers inherit, and any layer may override it, so a molded base under a laminated film is two processes in one design.

A process is authored data rather than a mode the app switches into, and it holds five things.

• Wall kinds it can form, each with a forming default: Vertical, Fillet (a radius) and Draft (an angle). A kind the process does not list, it cannot form.
• Corner radii it rounds by default — one for inner corners, at a corner of the void, and one for outer corners, at a corner of the material. 0 means sharp, which is an ordinary formed state rather than a missing value.
• Compensation — the scale at which a forming artifact is drawn so the finished part lands on size. It is applied at export and nowhere else, so the viewport, the design rules and every number you read are the nominal part. Left unmeasured, the process says so; a measured scale of exactly 1 is the different statement that parts land on size.
• Deliverables — which artifacts export can produce for this process.
• A rule deck — the subject of Design rules.

Presets seed a process you then tune: Soft lithography, Injection molding, Laser cutting, Micromilling, Hot embossing and Xurography. Loading one replaces everything the process holds — walls, corner radii, compensation, deliverables and rule deck; its name, and the stacks pointing at it, stay put.

Removing a process is refused while any stack references it, and the tooltip names the stacks to reassign.

What a process does not change

The geometry is process-neutral. Nothing you have drawn changes shape because you switched processes, and assigning a process your design violates is not refused — the model goes on building, and the Problems list says what that process cannot form. That is what lets one drawing be checked against two fabs.

See also

• Fabrication overrides — how a child departs from its layer’s defaults.
• Design rules — the rule deck a process carries.
• Stack window — where stacks and layers are edited.
• Fab processes window — where the process pool is edited.
• Layers — the panel that picks the stack, the active layer and what is visible.