What is Experiware

Experiware is a desktop application for designing microfluidic chips. You compose a chip from parametric components: channels, points and regions, grouped into reusable component definitions. Experiware maintains the resolved fluidic model and the layered 2.5D geometry as you edit, in both a 2D top-down and a 3D view.

A design targets a fabrication setup you author alongside it: a layer stack and a process (anything from soft lithography to injection molding) with its capabilities and design rules. Rule violations are reported in the Problems section as you work.

Designs are saved as .exw files. A .exw file can also serve as a component library: place another file’s components in your design through the Libraries section.

Start with A first look, then build something in Tutorial: your first chip. See Interface reference for every part of the app, and the Concepts pages for the model behind it.

A first look

Experiware opens on a sample design rather than an empty window, so there is something to fly around and click before you have drawn anything. Nothing about it is special: it is an ordinary document, and File → New clears it away.

The sample design

The sample is a droplet-microfluidics workflow, read left to right. A tee splits one sheath supply into two, which meet the dispersed phase at a flow-focusing junction; the droplet stream runs through a serpentine mixer and pours into a collection chamber. A second chamber sits on its own layer, connected to nothing — it is there so the design has two layers to look at.

Three of its connection points are open to the outside: the two inlets and the chamber’s outlet. The viewport draws each as a burst, so you can spot a port at a glance.

The title bar says Untitled — Experiware. The sample has never been on disk, so Save asks where to put it, exactly as it would for a new document.

The window

Five menus run across the top — File, Design, Edit, View and Help. Help → User Guide (F1) opens the guide you are reading.

The left panel stacks the quick settings strip over three sections: the Components and Libraries browser, the Layers list, and the Problems report. The viewport fills the middle, with the toolbar above it and the status bar below. The inspector is the right-hand panel, and it is where you edit.

Nothing in that frame opens or closes as you work. Every boundary is a drag handle, and where you drag it to is remembered. See Window & panels for each panel in turn.

The two views

Experiware opens in the 3D orbit view, where each shape is drawn with its depth — a channel stands as a bar, a chamber as a pad, and a wireframe box marks the slab they are cut into. Press Tab for the 2D top-down view. That is the view you draw in: it looks straight down, so nothing is foreshortened. Each view keeps its own camera, so Tab twice returns you to where you were.

Right-drag orbits, scroll zooms on the cursor, and middle-drag (or Shift+right-drag) pans. Press F to frame the whole design again after roaming. See Viewport & navigation for every gesture.

The selection

Left-click a channel. It lights in the viewport, the inspector’s lower section fills with its detail, and the matching row scrolls into view in the inspector’s Body tab — the panel and the viewport are two views of one selection.

Now click the collection chamber. The inspector fills with res, an instance of the Chamber component, and shows the parameters it was placed with — width, length, corner_radius. Most of the sample is placed components like this one, and the channels between them are drawn in place.

Esc clears the selection, and so does a click on empty space. Hovering names what is under the cursor on a small chip beside it. See Inspector for everything you can edit there.

The layers

The Layers section lists the sample’s two layers. Layer 0 is the active one: it is drawn in full color while the other is muted, and it is where a newly drawn shape would land. Clicking Layer 1 moves the emphasis and changes nothing in the design. Drag Explode and the layers separate along the stack axis, which is how you see a buried layer. See Layers for every control in it.

The Problems section

The Problems section is where the design-rule check reports. The check reruns after every edit, and the sample is clean, so the section reads no problems. Nothing here blocks you: a design with violations still builds and still exports, and you decide what to fix. See Problems for how a report reads.

Where to go next

• Tutorial: your first chip — build a small design from an empty document.
• Interface reference — every part of the app, one page each.
• Concepts — the model underneath: components, channels, regions, layers and rules.
• Keyboard & mouse reference — every key and button in one table.

Tutorial: your first chip

You will draw a chamber with one channel feeding it and one channel draining it, starting from an empty document. It takes about ten minutes and uses only the drawing tools.

1 · Start a new design

File → New (Ctrl+N). If the open document has unsaved changes, answer the question first; choose Discard.

A new document holds one empty component named Chip, already the root, over a single soft-lithography slab. That slab is Layer 0: 100 µm thick, with its features 40 µm deep. It is the only layer and the active one, so your shapes land there.

Press Tab for the 2D top-down view if you are not already in it. That is the view you draw in.

Leave Grid and Snap on in the strip at the top of the left panel. The pitch is 100 µm, so everything you place lands on a round number.

2 · Draw the chamber

Press R for the region tool and drag a rectangle in the middle of the viewport, roughly 2000 µm across. Hold Shift while dragging for a square.

Releasing creates a region, an area carved into layer 0 at that layer’s 40 µm depth. It appears in the inspector’s Body tab as rg, and the inspector’s lower section shows its detail. The fill control there reads void, which means the fluid is inside it.

Throughout the gesture, the chip beside the cursor names what the release will make. See Regions & compartments.

3 · Place the inlet point

Press P for the point tool and click once, well to the left of the chamber. A point is a terminal, a place a channel can end. It fabricates nothing on its own, so it draws as a marker and not as geometry. It is 100 µm wide and lands in the Body tab as point.

The tool has already returned to Select. A single click of a toolbar button picks a tool for one use; double-click the button to latch it when you want to place several.

4 · Draw the feed channel

Press D for the channel tool. Press on point, drag to the chamber’s left wall, and release on the wall itself.

The drag makes two children: a wall-bound point on that edge, labelled p, and the channel ch that connects your inlet to it, breaking through the wall there. One gesture made both, so Ctrl+Z takes them back together.

Releasing on a wall is one of the four ways a channel end can resolve. See Channels & points.

5 · Draw the outlet channel

Press D again. This time press on the chamber’s right wall and drag out into empty space to the right.

Both ends resolve the same way, so this gesture makes two points: a wall-bound p2 where you started and a free p3 where you released, joined by the channel ch2.

Fluid enters at point, crosses the chamber, and leaves at p3.

6 · Widen the inlet

Click point to select it. The inspector’s lower section shows its placement, its layer offer and its width. Drag the width field to scrub it, or type 200 and press Enter.

The channel widens at that end only and tapers back to 100 µm where it meets the wall. Width is a value at each vertex and is interpolated between them, and a channel end with no width of its own takes the width of its point. Select p, give it 200 as well, and the channel comes out one width along its whole run. See Channels & points.

7 · Expose the ports

Right-click point and choose Expose as pin. The point becomes a connection the component offers to whoever places it, under the same name.

Select point and tick world port in its detail. A world port is an opening to the outside — an inlet or an outlet — and the viewport marks it with a burst. The side combo beside the tick says which face of the chip it comes out of; leave it at down. Do the same for p3.

The two ticks are independent: exposing a pin publishes the terminal to whoever places this component, while the world mark cuts a hole in the finished chip. A terminal with neither is an interior connection, sealed inside the assembled chip.

The port is named after the terminal, so rename the point in the label field at the top of its detail if you want the port called something else.

8 · Look at the chip in 3D

Press Tab. Your shapes are drawn with their depth now, 40 µm each, and the wireframe box around them is the 100 µm slab they are cut into.

Right-drag orbits, scroll zooms on the cursor, middle-drag (or Shift+right-drag) pans, and F frames the whole design again.

The chip is open at the top: what seals a soft-lithography device is bonded on at fabrication, and the design does not model it. See Layers, stacks & processes.

9 · Check the design rules

Look at the Problems section. It should read no problems: your channels are wider than the process’s 10 µm minimum, everything sits at one depth on one face, and the design fits the substrate.

If a row does appear, click it, and the inspector opens on the child that would fix it. The check never blocks an edit or an export. See Design rules.

10 · Save the file

Ctrl+S. The document has never been saved, so Experiware asks for a path first. Designs are .exw files, and one format covers both roles: another design can place this file as a component library without converting anything.

The • in the title bar marks unsaved changes and clears when the file is saved. It tracks your edits, so undoing back to this point clears it again.

Where to go next

• Components, parameters & pins — give Chip parameters, and place it inside another component.
• Regions & compartments — divide that chamber, weld a corridor onto it, stand a post in it.
• Fabrication overrides — make the chamber deeper than the channels running into it.
• Export — the files a process publishes from a finished design.
• Toolbar & tools — every gesture the drawing tools accept, in full.

Window & panels

The window is one fixed frame. The menu bar runs across the top; under it the left panel, the viewport and the inspector sit side by side; the toolbar spans the viewport above and the status bar below. The one row that ever appears on its own is the update banner (→ The update banner).

The menu bar

The menu bar spans the full width of the window, above everything else: File, Design, Edit, View and Help. The first three act on the document, View switches between the 2D and 3D views, and Help opens this guide, checks for updates and shows the About box. See Menus & files.

The left panel

The left panel is a strip of quick settings over three sections, each scrolling its own content.

The strip holds Grid, Snap, and the gear that opens the Settings window; the rest of the preferences live behind the gear (Settings).

Under it, in order, are the three sections:

• Components and Libraries — the browser’s two tabs, listing the components you can open and place (Components & Libraries);
• Layers — the stack picker, the base layer, the explode slider and one row per layer (Layers);
• Problems — the live design-rule report (Problems).

The viewport

The viewport fills the middle of the window and shows the design in 2D top-down or 3D orbit view (Viewport & navigation). The toolbar above it holds the tools and the options for whichever tool is active (Toolbar & tools).

The inspector

The inspector is the right-hand panel, and it is where you edit. A header names the open component, over a tabbed section for the component and a section for the selection inside it. See Inspector.

The status bar

The status bar is a single line under the viewport.

At the left is the legend: the current view mode, what the next click and drag do with the active tool, and the navigation keys. It updates as you work. Beside it, a finished action leaves a short note (3 files written to …) that clears itself after a few seconds. At the right end sit three readouts. The outermost is the pointer’s position, described below. Inside it, ⚠ N library warnings appears when the last file you opened had something to report about its libraries, and ✕ N ⚠ M counts the outstanding design-rule errors and warnings whenever the report is not clean. Hover either count for the details. Clicking one does nothing; the Problems section is the list you click.

The position reads x 1 234.5 · y -678.9 µm: where the pointer is on the active layer’s plane, in microns like every other length in the app, with long numbers grouped in threes. It is unsnapped: it says where the pointer is, not where a click would land.

It shows fewer decimals the further you zoom out. In the 3D orbit view it names the layer as well, Layer 0 · x … · y …. It reads — when an edge-on view leaves the pointer on no plane at all, and is blank while the pointer is outside the viewport.

Boundaries and sizes

Both side panels resize from their inner edge, and the boundary between two sections is a drag handle. The pointer becomes a vertical resize arrow over it, and the line lights as you hover and again as you drag.

Both widths and every section height are stored with your other preferences, so the next launch opens on the layout you left (Settings).

Windows and dialogs

The Settings window and the two fabrication editors — Fab processes and Stack — float over the layout, are dragged by their title bar, and close from their own ✕. The design stays editable underneath while one is open.

All three resize: drag an edge or the bottom-right corner. Each stops at a floor that keeps its top row readable, and a form longer than the window scrolls inside it rather than running off the bottom. What you drag to lasts as long as the session; unlike the panel widths, it is not stored with your preferences, so the next launch opens them at their usual size.

The export dialog, the unsaved-changes question, the file-error report and the About box each dim the window behind them and take every click until you answer them.

The update banner

When the update check finds a newer release, a row appears under the menu bar naming the version, carrying a Download link and a ✕.

The ✕ dismisses that release and only that one — the release after it announces itself again. The check that raises the banner, and its off switch, are Settings → Updates.

See also

• Keyboard & mouse reference — every shortcut the status bar hints at, in one table.

Viewport & navigation

The viewport is the middle of the window. Everything you place, draw, move and select happens here. The panels around it are views of the same thing, so a click on geometry and a click on the matching row are interchangeable.

The two views

The 2D / 3D pair at the right end of the toolbar switches between them and shows which one you are in. Tab switches too, from anywhere except a text field you are typing in, and View → 2D top-down / 3D orbit is the third way.

The 2D top-down view looks straight down at the design and draws each layer’s top face flat. It is the view you draw in. Nothing is foreshortened, so two shapes of the same size look the same size wherever they sit in the view.

The 3D orbit view draws each shape with its depth: a channel stands as a bar, a chamber as a pad. What is drawn is the void — the material around it is not, and a wireframe box marks how far the active layer’s slab reaches.

Each view keeps its own camera, so switching and switching back returns you to where you were. The grid is drawn under the design in 2D and on the active layer’s plane in 3D; its pitch and its snapping are in Settings.

Where a region holds more than one pocket, the flat view outlines each with a hairline, which is what tells two abutting pockets apart. A hole needs no line. See Regions & compartments.

Camera navigation

The camera is on the right and middle buttons and never the left, so it stays available whatever tool is active.

Right-drag orbits in 3D and pans in 2D. Shift+right-drag pans in 3D, and middle-drag pans in either view.

Scroll zooms, centered on the cursor: the point under the pointer stays under it.

A pan grabs the point under the cursor and holds it there. In 3D that needs a point to grab — a press on empty sky above the design has none, and the pan does not start.

F frames the camera on the selection, or on the whole design when nothing is selected. It is also how you recover from an edge-on view.

The scale bar

The scale bar is a ruler in the viewport’s bottom-left corner, with the distance it spans written above it. It is always on and does not follow the Grid switch.

It always spans a round figure — 5 µm, 500 µm, 2 mm. It reads in mm from a millimetre up; every other length in the app stays in microns.

In the 3D orbit view the bar is true at its own corner rather than across the whole viewport, since a tilted camera draws the far side of the design smaller than the near side.

The pointer readout

A chip beside the cursor names what is under it. A child reads label : kind. A pin reads its owner and its own name, mixer / out. A compartment reads its region and its own name, chamber / hole 1 : hole. A terminal the open component exposes adds → name after that once its pin name differs from the terminal’s own, and a world port adds a » either way.

Hovering also lights the thing itself, and the row that names it in the inspector’s Body tab.

Hover follows the active tool and shows what a press would take. Under Add point, Add component and Draw region nothing lights, and the crosshair is the only cue. While you are drawing a region the chip carries what the release will make instead of what is under the cursor.

Selection

A left click selects the child under the cursor, and a click on empty space clears the selection.

Inside a region the click names the compartment you pointed at, hole included: the whole area inside a region’s outer ring answers to a click, not only the parts that are carved. A region holding a single compartment selects as the region itself.

Where two shapes lie under the cursor the nearer one wins, so a click inside a hole in an upper layer selects that hole and not the shape you can see through it. Between two at the same height the one on the active layer wins.

Esc does the first of these that applies. It closes an open context menu; else it abandons the gesture you are drawing, keeping the tool so you can start again; else it returns a non-Select tool to Select. With nothing else to do it steps the selection out one tier — vertex, then compartment, then the child, then nothing.

Handles and markers

Shape says what a marker is:

• a circle is a terminal you can connect to;
• a diamond is a child’s position — a placed component, a region or a channel;
• a square is a vertex you can edit;
• an outlined triangle flags a design-rule violation (Problems).

A child that has geometry shows its diamond only while you hover or select it; a point, which has none, shows its circle always. Hovering or selecting grows a marker and lightens it. The hue says what kind of marker it is, not which layer it is on; a terminal on an inactive layer is muted with its layer.

A terminal offering more than one layer draws a circle on each, joined by a vertical stem. One offering all layers has no particular run to draw, so it draws a single circle carrying a double-headed vertical arrow instead.

A channel’s or a region’s vertices become grabbable only while that child is selected. A press on one selects that vertex, and the inspector grows a section for it.

A selected placed component gets a box drawn around it. A channel or a region gets its own shape traced instead, and a point gets neither.

Openings

Where the network reaches the outside or changes slab, Experiware draws the hole that gets it there: a cylinder on the bore’s axis, one per slab the hole goes through, spanning that slab’s full thickness. Explode the stack (Layers) to see them separately — each cylinder travels with its own slab, so the gap between them opens up like everything else. The stem through a terminal’s markers is what shows the connection across that gap.

They are drawn as narrow shafts by default, which keeps them from covering the channels they land on. Settings → Viewport → Openings switches to the true diameter or turns them off.

Two cases draw nothing. An opening with no material to remove — two channels on neighbouring slabs that already meet across the bond — is real and cuts nothing. And a terminal you marked as a world port but have not connected yet forms no opening at all, since there is nothing for it to open into.

A bore is not selectable. Clicking one selects whatever is under it; select the point that formed it to size its punch (Inspector).

The left-drag

Left-drag moves what is under the pointer. The whole drag is one undo step, and so is a placement you position in the same press.

Shift locks the movement to one axis. The axis is the direction you travel after pressing it, and motion freezes until that is decided. Ctrl inverts grid snapping for that one drag.

What travels depends on what you grabbed: a nested compartment moves within the shape containing it, welded compartments come along together, and a wall-bound point slides along the wall it rides and never leaves it.

The context menu

A right-click opens the menu for whatever is under the cursor. It opens in the Select tool only, and only when the button did not travel, since a right-drag is camera navigation. Over something with nothing to offer, no menu opens.

The rows, by what you clicked:

• a channel’s body — Insert vertex here, Delete channel
• an interior vertex of a channel — Promote to point, Delete vertex
• a point — Expose as pin or Unexpose, Dissolve into channel, Delete point
• a placed component’s pin — Expose as pin or Unexpose
• a region’s fill — Insert vertex here, Delete region
• a vertex on a region’s ring — Delete vertex, and on a nested compartment’s ring the delete for that compartment (Delete compartment, Delete pocket or Delete hole)

Each of these is an action the Inspector also offers, except Insert vertex here, whose other surface is the Insert vertex tool (Toolbar & tools). A row the app would refuse stays visible and grayed, with the reason in its tooltip.

Esc, a click on a row, a press outside the menu, or picking another tool closes it.

See also

• Toolbar & tools — what the left button does under each tool.
• Inspector — the panel the selection feeds.
• Channels & points — the points and vertices the circles and squares mark.
• Components, parameters & pins — the pins and world ports the pointer readout names.
• Layers — the active layer, visibility and the explode gap.
• Settings — the grid, snapping, the inactive-layer mute and the opening switch.
• Regions & compartments — compartments, welds and seams.
• Keyboard & mouse reference — every key and button in one table.

Toolbar & tools

The toolbar is the strip above the viewport: the tools at the left, the options for whichever tool is active beside them, and at the right end the 2D/3D view switch and the Fab processes button. A tool decides what the left button does in the viewport; the camera stays on the other buttons.

The tool strip

The strip holds six icon buttons, five of them always present, with one of them active. Hovering a button names the tool and its key (Draw channel — D), and each key behaves exactly like a click of its button.

A single click picks a tool for one use: it returns to Select as soon as one action completes. A gesture you cancel keeps the tool active. Double-click a button to latch it — a push-pin appears beside it and it stays active after each use, until you press Esc or pick another tool.

The pointer is a crosshair under every tool but Select, where it stays an arrow.

While you have a component from Libraries open, you can still pick a tool and still click to select, but no tool creates or moves anything and no context menu opens — another file’s component is read-only.

Select — S

Select is the tool you return to: click to select, drag to move, right-click for the context menu. It is the only tool with a menu. See Viewport & navigation.

Draw channel — D

Draws one channel between two terminals — a point, or a pin of a component you placed. The gesture has two forms, and both resolve each end the same four ways, in order:

• a pin or a point — the channel connects to it;
• another channel’s body — that channel is split at the click, and a new point between the halves becomes the junction;
• a region’s wall — a wall-bound point is created on that edge and the channel breaks through there;
• empty space — a new point is created there and connected.

Drag from the start and release on the end for a straight run. Or press and release without moving to anchor the start, then click each bend in turn: a click on a target finishes there, and a double-click or Enter finishes at the last bend you placed.

Once the start is anchored, Backspace retracts the last bend. Esc abandons the gesture in either form. Releasing back onto the start, or anywhere on the region it starts from, cancels — there is no channel from a terminal to itself. While you are still dragging, a right-click drops a bend without ending the gesture.

The channel and everything the gesture created are one undo step.

Add point — P

Each click places a point at the cursor on the active layer, snapped to the grid when snapping is on. Keep the button down and drag to position it before you release; the placement and the nudge are one undo step.

Add component — C

Places an instance of the component picked in the options row, with the same press-and-drag behavior as Add point. With nothing picked the picker reads (pick) and a press places nothing.

Draw region — R

Drag from empty space to sweep out an axis-aligned rectangle, holding Shift for a square. Press and release without moving — or press anywhere that snaps to an existing wall — to start a polygon: each click places a vertex, and the ring closes when you click the first vertex, double-click, or press Enter.

Backspace retracts the last vertex — the first one is the corner you pressed on and stays. Esc abandons the gesture.

Where you press decides what you draw: empty space a new region, inside a pocket a hole, inside a hole a pocket. Every vertex you place snaps — to a nearby vertex, else onto a nearby edge, else to the grid while snapping is on — and one placed on an existing wall welds to it. The chip at the cursor names what the release will make — weld to, carve, split into — or why it will not; see Regions & compartments for what each one produces. The preview outlines the ring the release would make, drawing vertices borrowed from a welded wall more faintly than the ones you placed.

Clicking a wall more than once decides how much of that wall your shape takes:

• Click a wall twice and the run of wall between the two clicks joins your shape. A corridor off a chamber takes four clicks, two of them on the wall.
• A shape closes itself when its last wall click can reach the first one along the wall.
• Starting off the wall turns that self-closing off, which is what a shape meeting one wall in two separate places needs.
• To leave out the wall between two clicks, put a vertex off the wall between them. The chip asks for a vertex off the wall in two cases: where two runs of wall would both fit (can’t tell which side), and where no edge can be routed along it (no way to route that edge along the wall).

A refused release commits nothing. The rectangle is dropped; a polygon stays open with its vertices intact, so one Backspace puts you back where you were.

Insert vertex — I

The button appears, and the key works, only while a channel or a region is selected. Clicking inserts a vertex on the nearest segment of that shape, landing exactly on it — so nothing changes shape until you move it. Drag in the same press to position it straight away.

The options row

The options row sits beside the tools and appears only for a tool that takes input. Select, Add point, Draw region and Insert vertex show nothing there.

Draw channel shows Width in µm. Drag the field to scrub it or type a value and press Enter; it will not go below 1 µm. It is the width given to each point the gesture creates, and channel ends inherit from their points, so it is the width the run comes out at. See Channels & points for how an end inherits. Like the grid pitch it is a preference and not part of the design (Settings).

Add component shows the Component picker: your own components first, then each library under a dim heading you cannot pick. The component you have open is never listed — it cannot contain itself.

The view switch

The 2D / 3D pair sits right of the tools, with the view you are in shown pressed. It is the same switch as the Tab key and the View menu. See Viewport & navigation.

The Fab processes button

The button at the right end of the toolbar opens the Fab processes window, the same window Design → Fab processes… opens. Which process a stack is built with is shown in the Stack window.

See also

• Viewport & navigation — selection, moving things and the context menu.
• Channels & points — what the drawing tools create.
• Regions & compartments — welding, and what a drawn ring becomes.
• Layers — the active layer a placement lands on.
• Keyboard & mouse reference — every tool key in one table.

Components & Libraries

The browser is the top section of the left panel, and it is what you open a component from. Two tabs share it: Components, the definitions this design owns, and Libraries, everything it can place but not edit. Clicking a name opens that component — the viewport shows it on its own, and the inspector fills with it.

The tab strip

A tab carries a count when there is something behind it, and Libraries counts libraries, not their components: a catalog of three libraries holding forty components reads Libraries 3.

The + adds to the tab you are looking at, and only Components has one — a library is a file beside the design rather than something you make here. Each tab keeps its own scroll position, and the tab you pick stays picked as you move between components.

Components

The tab lists one row per definition this design owns; a design with none reads (none).

A small dim star follows the root, and clicking it does nothing. The star that sets the root is in the Inspector header, which is also where a definition is renamed and deleted.

The + creates an empty component named component (component2, and so on, when that name is taken) and opens it. The new component is not made the root.

Opening a component reframes the viewport on it, clears the selection inside it, returns the active layer to the stack’s base layer, and shows every layer again. Editing does none of that: the Layers visibility you set survives everything but a change of component and making a hidden layer active.

Libraries

The tab lists one collapsible group per library, Built-ins first and the rest by name. Built-ins ships with the app, and every other group is a library file in the folder beside the design you opened. The group header carries that library’s @version, and the tooltip gives the full identity. Two versions of one library are two groups, which keeps components that share a name apart.

A dimmed header is a library loaded from the folder that this design does not use, and its tooltip says so. The dimming tells you which files have to travel with the design when you share the folder. Placing a component from a library undims it; opening one to look at it does not.

A library component is read-only. Opening one shows its parameters, computed values and pins with no edit controls, and the tools do nothing in the viewport while it is open. You use one by placing it, from the toolbar’s Add component picker (Toolbar & tools), which lists the dimmed libraries too.

When the last file you opened had something to report about its libraries, the status bar shows a ⚠ N library warnings readout. Two things raise one: a library file that changed since this design was last saved, which re-saving clears, and a file beside the design that could not be read and that this design does not need.

See also

• Components, parameters & pins — definitions, the root, and what each built-in component is.
• Inspector — where the open component is renamed, re-rooted and deleted.
• Toolbar & tools — the Add component picker that places what this browser lists.
• Window & panels — the section’s place in the frame, and the status-bar readouts.

Layers

The Layers section is the middle of the left panel, and it is the stack as you view it. It shows which stack the viewport is showing, where the design is anchored in it, how far it is exploded, and one row per layer. Adding a layer and setting its thickness, material or process is the Stack window’s job; this section holds the controls you reach for while drawing.

The stack group

stack names the stack driving the viewport, and picking another one makes it the active stack: the design rebuilds against its thicknesses, materials and processes. That is a design edit and one undo step, not a view setting. The pencil beside it opens the Stack window.

base layer is the layer of that stack the open component anchors at — its own layer 0 sits there. The row is absent while the stack has no layers. See Layers, stacks & processes for the difference between this anchor and the active layer.

Explode opens a gap between the layers, from 0 — the stack as it bonds — up to 5000 µm. The gap runs along the stack axis, so the 3D view is where it shows, and the camera pulls back as you drag so the taller stack stays framed. Shapes are drawn opaque, so explode is how you see one layer under another. Like the grid pitch it is a preference: outside the design, outside undo, and kept between sessions (Settings).

The layer rows

The section shows one row per layer of the active stack, an empty layer included. An empty layer has nothing to show, but it can be made active and drawn on. A stack with no layers reads (no layers).

The swatch is the layer’s color in the viewport, shaded by the layer’s default face and muted while the layer is not the active one.

Layer N is the pick: clicking the label makes that layer active, and the active layer is drawn vividly against the muted rest. It changes nothing in the design and costs no undo step. There is always one active layer, so a click on the active row does nothing.

The checkbox at the end of the row hides the layer. It is disabled on the active row — you author on what you can see, and the tooltip says so. A slab carrying features on both of its faces gets two toggles instead, tagged T and B, and an empty layer gets none — there is nothing there to show or hide.

Hiding is a view state and never an edit: nothing is deleted, and an export is unaffected. It does change what the pointer can reach: you cannot select a shape on a hidden layer, and a region you draw will not weld to one. Visibility resets when you open another component (Components & Libraries), and making a hidden layer active shows it again. Nothing else disturbs it.

See also

• Layers, stacks & processes — the stack, the base layer, faces and depth.
• Stack window — where layers are added, ordered, and given a thickness and a process.
• Viewport & navigation — the two views the explode gap and the visibility flags act on.
• Settings — the inactive-layer mute the swatch and the viewport share.

Problems

The Problems section is the bottom of the left panel — the design-rule report, recomputed on every committed edit. Its title carries the running count, Problems · ✕ 3 · ⚠ 1, with each half dropped when it is zero. A clean report shows a dim no problems line.

See Design rules for what each rule measures.

A row

✕ inlet feature 5 µm < 10 µm min · worst of 37 places · film

Each row is one finding: the severity glyph — ✕ an error, ⚠ a warning — then the child the finding is attributed to, then the finding itself. The line truncates in a narrow panel, and the tooltip carries it whole.

The finding reads as the measurement against the limit it failed, in µm and named for what was measured. The rules that have no threshold — a self-crossing outline, compartments that do not join up, material with nothing holding it — read as a plain statement instead.

worst of 37 places says how many places the row stands for, and that the measurement in front of it is the worst of them. A row standing for a single place carries no such clause.

The last field is the process whose deck set that limit. See Design rules for which process that is.

Hovering a row lights its subject in the viewport and adds the markers for that row’s other places; clicking selects the subject, so the inspector opens on what would fix it. A row reading (layer) has no subject to select, so clicking it selects nothing. It is a finding about a whole layer, such as more depths in it than the process forms in one go.

Rows run errors first, then by child name, with the layer-wide findings last.

Rule groups

Past ten rows the list folds into one collapsible group per rule, each header carrying its glyph, the rule’s name and its total (✕ Min wall · 37) and starting closed. A header names a rule and not a child, so hovering or clicking it does nothing; open it and the rows under it behave as they always do.

Where one rule accounts for nearly the whole of a large report, its header adds a question — 1240 of 1250 places — check the process?.

The unchecked-rule line

Under the list, a dim not checked yet: Min aspect ratio names the rules that are enabled on a process forming your design but have no checker. Those rules produce no rows, and the tooltip on the line says so.

The line stays hidden unless you tick such a rule yourself, and it appears on a clean report too. See Design rules for which rules can raise it.

The counts

The title’s ✕ N · ⚠ M counts places, not rows: a row standing for 500 of them adds 500.

The same pair sits in the right half of the status bar whenever the report is not clean, inboard of the cursor coordinates, with the first few findings on its tooltip. Clicking one does nothing.

See also

• Design rules — what each rule measures, and which process governs a finding.
• Viewport & navigation — the outlined triangles a row’s places are drawn as.
• Fab processes window — where a rule deck’s thresholds are edited.
• Inspector — where the subject of a clicked row is edited.

Inspector

The inspector is the right-hand panel, and it is where you edit. It shows three things at once: the component you have open, the child or compartment selected inside it, and the vertex selected inside that. The upper section is the component; the lower section is the selection. Drag the boundary between the two, or the panel’s left edge, to give whichever you are working in more room — both are remembered.

The header

The header names the open component and carries the three actions that apply to the component as a whole.

The name is editable in place and commits when you press Enter or click away. A name that is empty, already taken, or not a valid identifier is refused, and the field returns to the real name.

The star sets the component as the design’s root — its top-level component, the one the file opens at. It is disabled, and stays gray, when the component already is the root.

The trash deletes the component. The deletion is refused if the component is the root, or if another component places it; the button is disabled and the tooltip says which of the two applies.

A component opened from Libraries is another file’s definition, so the header drops to a plain heading marked built-in component (read-only) and no edit controls appear.

If the open component cannot be built — an expression that does not type-check, a missing argument — the reason appears in red under the header and stays there while you fix it. The viewport goes on showing the last version that built.

The tabs

The component has four tabs: Params, Computed, Pins and Body. A tab carries a count when there is something behind it. The + on the tab strip adds to the tab you are looking at, and appears only on Params and Computed — pins and children are created elsewhere. The tab you pick stays picked as you move between components. A built-in shows three tabs; it has no authored body.

Params

name │ type │ default │ 🗑

These are the component’s inputs — what someone placing it can set. + adds a row.

The type dropdown commits as soon as you pick. The default editor matches that type: drag a number and the viewport follows, release to commit; typed values commit on Enter or focus loss. A parameter loaded without a default reads (required) and is not editable here. Deleting a parameter that something refers to is refused, and the tooltip lists what refers to it.

Computed

name │ (type) │ expression │ 🗑

These are values derived from the parameters by expression. You author the name and the expression; the type is inferred rather than declared, which is why the type column is parenthesized and read-only. It reads (?) while the component does not type-check — the error under the header says why.

The expression commits on Enter or focus loss. One that does not parse does not take effect.

Pins

name │ source │ 🗑

These are the connection points the component exposes to whoever places it — its published contract, and nothing else. What a terminal is — whether it is a world port, how big its punch is — sits in the terminal’s own detail, reached by selecting it here or in Body.

The name renames on Enter or focus loss. It locks, with the references in its tooltip, while another component refers to the pin — a rename would break it. The source names the terminal behind the pin (← p1, ← mixer / out); it is hidden when it would only repeat the pin name. Clicking anywhere on the row selects that terminal, and hovering it lights the terminal in the viewport.

There is no + here. You expose a pin from the terminal itself: right-click a point or a placed component’s pin, or use the Expose button in its detail block.

Body

The tab shows the component’s children as a tree: placed components, channels, points and regions, with a region’s compartments nested beneath it.

This is the same selection the viewport uses, so a row click and a click on the geometry are interchangeable, and selecting in the viewport scrolls the matching row into view. Hovering a row lights the child. The trash on a row deletes it, and is refused with a reason when something refers to the child by label.

The selection

The lower section shows what is selected. It is always there, and with nothing selected it says so.

The breadcrumb

Pinned at the top of the section, the breadcrumb names the chain of scopes down to what you are editing — child, compartment, vertex. Every crumb above the last is clickable, so it is also how you step back out. A compartment leaf carries a trash beside the chain, and it removes what that last crumb names; a child is deleted from the Body tab and a vertex from its own group below, so neither puts a trash here.

A selected child

What the detail shows depends on what kind of child it is.

A placed component shows its pos, rot and layer placement rows, then its args, one row per parameter of the component it places. Each args row has a checkbox that overrides the parameter or returns it to the placed component’s own default. Below those sits one row per pin the placed component exposes, with an Expose button that forwards the pin through the component you are editing, or a readout of the name it is already forwarded as.

A channel has no placement rows — its placement is fixed, anchored to the terminals at its ends, and the panel says so. Instead it shows an ends block: one row per end, naming what that end connects to (end 0 · at p1), each carrying that end’s width control, which is either inherited or explicit. Hovering an end row lights the terminal it connects to.

A selected terminal inside a placed component — a pin row in Body — shows its own section under the component’s detail: an offer row, the world port tick and the bore rows. The offer row is the point’s own count and all tick plus a floor, since a terminal inside a component has no layer row of its own to anchor to; unticked, it reads the offer the component published, dimmed and marked · component. Both numbers are relative to the terminal, and the absolute range they work out to is echoed after them.

Every terminal, wherever it is selected from, carries the same three blocks under whatever else its detail shows: the world port tick with the face it exits by beside it, the offer row, and the bore rows.

punch size is the hole’s diameter, operation is what cuts it (punch, drill, or molded in by the tool itself), stage is whether it is cut before or after the layers are bonded, and pad offset is how far the channel is widened where the hole lands, so the tool has something to hit. Each row is an override checkbox: unticked, it shows the value it inherits, dimmed and marked with where that came from — · point for a value the point behind a component’s pin authors, · process for the shop’s default. Ticking seeds the value already showing, so the tick alone changes nothing.

The rows describe the opening this terminal would form, so they stay editable on a terminal that forms none, with a line above them saying nothing opens there yet. Two openings answer stage themselves and the row greys out saying which: a molded-in hole is made with the part, and a via buried between two layers has no way in once the stack is bonded, so both are cut before assembly whatever the row was set to. What you authored is kept underneath and applies again if the opening stops being either. See Channels & points for what forms an opening in the first place.

A point shows its placement, its offer and width, and whether it is exposed as a pin. The offer row is a count of layers with an all tick beside it, and the range it works out to is echoed after them; a wall-bound point rides one slab, so its row is greyed — with an Expose as pin button when it is not. The detail also carries Dissolve into channel, disabled with a reason where the point does not qualify. See Channels & points for what it merges.

A region is edited one compartment at a time, so its detail is the compartment’s.

A selected compartment

The outermost compartment is the region child, so its detail opens with the region’s own placement rows. A nested one opens with a name field — leave it empty and it falls back to the derived label shown dimmed beside it — plus dx, dy and rot. See Regions & compartments for what those rows move and why a nested compartment has no layer row.

Under those, region · N vertices names the ring, and the fill control below it says what the compartment is: void is a carved pocket, material is untouched slab. Switching a void compartment to material is how you make a hole; switching it back makes a pocket. The material direction is disabled where it would leave material inside material, and on a region’s outermost compartment, which is always void; the tooltip says which case applies.

Fabrication

Void compartments and channels carry a fabrication group of override rows; a point carries the same group with the two corner-radius rows alone. Each row has a checkbox: ticked, the value is this child’s own; unticked, it is inherited, and the effective value is shown dimmed beside the name of what it came from. Ticking seeds the override from whatever the row is displaying, so ticking alone changes no geometry. Unticking clears it and returns to tracking the inherited value.

face chooses which side of the slab the shape is formed from, and appears only at the scope that is the child itself. depth in µm is what makes a chamber deeper than the channels running into it, or a pocket a step in that chamber’s floor. walls is the wall profile — its second row appears only when the profile has a parameter to set. The two corner-radius rows close the group, inner and outer.

face, depth and walls inherit from the child’s layer; corner radii inherit from the process forming it. A child sitting off the stack has no layer to inherit from, so its unset rows read — and cannot be ticked. Existing overrides stay removable either way.

A selected vertex

Selecting a single vertex adds a group at the very bottom, titled with what it is (Selected vertex — rg · hole 1 · vertex 2 / 5) and carrying the delete for it. A channel’s vertex shows its pos and width; a region’s shows its position local to the compartment. A channel’s vertex carries both corner-radius rows; a region’s carries one, for the class its own corner takes. Either overrides the child’s.

Deleting a region vertex is refused at three — a region needs at least three vertices. A channel’s interior vertex always deletes; removing one straightens the channel through it.

See also

• Components, parameters & pins — the model behind the Params, Computed and Pins tabs.
• Channels & points — what the children in the Body tab are.
• Regions & compartments — the model behind the compartment detail and the fill control.
• Fabrication overrides — the inherit/override rule the fabrication group and the corner rows follow.
• Layers, stacks & processes — what those rows inherit from.

Fab processes window

The Fab processes window is where a process is authored. It opens from Design → Fab processes… or from the toolbar’s Fab processes button, and it floats over the layout: you can draw, and watch the Problems section recompute, while it is open.

Processes are a shared pool, so the window edits whichever process the strip shows, which need not be the one the viewport is built with. You can tune a molding profile while a soft-lithography stack drives the display. Which process a stack is built with is set in the Stack window.

The process strip

The picker lists the design’s processes, and choosing one says which process the rows below edit. It changes nothing about the design and costs no undo step.

Beside it sit three buttons. + opens a menu of the built-in presets and creates a fresh process from the one you pick. The copy button duplicates the shown process under a new name, which is how you diverge from a preset you have already tuned. The trash removes it, and is refused while any stack references it; the tooltip names the stacks to reassign first. That also covers the last process — with one left, every stack references it — so a design can never be left without one.

The row underneath reads who is using it: used by stacks: proto, prod, or not referenced by any stack. The name field beside it renames the process on Enter or focus loss; the stacks pointing at it follow the rename.

The preset row

Load preset reseeds the whole process from a built-in preset, as one undo step. See Layers, stacks & processes for what loading replaces and what it leaves alone.

Loading is one-way, and the control never reads back which preset a process came from.

Deliverables

The list holds the artifacts this process publishes; tick the ones the shop it goes to wants. A preset has the usual choice for its route already ticked, and sending a stack two ways takes one more tick. See Deliverables for what each one is and what it writes.

A row marked not exported yet is an artifact that is described and this version cannot write — the part solid. Tick one anyway when it is what the shop takes — the export dialog then keeps its row too.

Leaving the list empty is allowed. It says this process publishes nothing, and the export dialog names each layer it leaves without files.

Compensation

Shrink measured is off until someone has measured how this process’s finished parts compare to the drawn size, and while it is off the row reads not measured. Ticking it reveals a percent field for the measured shrink, with the correction it derives shown dimmed beside it (→ export scales ×1.00503). You author the shrink because that is the number a datasheet quotes and a test part gives; the scale is what export applies.

The dim sentence under the row is the statement every exported file will carry. Ticking the box and typing 0 claims parts land on size; leaving it unticked says nobody has checked.

Corner radii

The two fields in µm, inner (void) and outer (material), are the radii this process forms at a corner of the void and at a corner of the material, and 0 in either is a sharp corner. See Fabrication overrides for the two authoring tiers that override these.

Wall kinds

There is one row per profile — Vertical, Fillet, Draft — each with a checkbox saying whether the process can form it. A kind left unticked cannot be chosen anywhere the design authors walls.

Fillet and Draft take a parameter, and a ticked row carries its forming default beside the checkbox, in µm radius or ° draft. A row with no default published reads a dimmed 0, which means the author supplies the parameter per feature. Vertical takes none, so its row is the checkbox alone.

Unticking a kind the design is already using is allowed and changes no geometry. See Design rules for what the Problems section then reports.

Openings

The four rows say how this process cuts the holes that reach a channel — a punched inlet, a via between two slabs, a well into a chamber. punch size is the diameter in µm, operation is what cuts it (punch, drill, molded in) and stage is whether it happens before the sheets are bonded or through the finished stack.

pad offset is how far the channel is widened where a hole lands on it, in µm. A punch is millimetres across and a channel is tens of microns wide, so without a pad the tool has to hit a line; the pad flares the channel’s end into a round tip the hole sits inside, and does the same at a junction or a via. It applies at every layer the hole touches, including the one it lands on — which is what keeps a via connected when the slabs shift slightly against each other. The presets ship 0, which changes no geometry, so set it once you know the margin your shop needs.

These are the shop’s answers, and every opening in the design takes them unless its own terminal says otherwise, so setting drill here is one edit rather than one per port. A terminal that does author a value keeps it; see the bore rows in the Inspector.

The process a stack is built with answers for every opening in it, including one crossing two slabs whose layers are formed by different processes: an opening goes through the part rather than being formed in one layer, so the part’s own process is the one that owns it.

The rule deck

☐ name │ threshold │ ✕

The deck lists one row per rule the app knows, whether or not this process carries it. The checkbox says whether the deck carries that rule. Ticked, the rule is checked and the row shows its threshold; unticked, the rule is not checked at all, which is what an absent rule means. Ticking one seeds a starting threshold at Error severity for you to type over.

The severity button flips ✕ error and ⚠ warning — the two glyphs the Problems section uses.

Two rules are authorable but have no checker, and their rows say not checked yet — ticked or not, and on every process. No preset enables either, so ticking one is what makes the Problems section repeat it under the report. See Design rules for which two they are.

Most thresholds are one number: µm for a length, × for a ratio, or a bare count. These carry more:

• Min inner radius and Min outer radius have a floor checkbox. Unticked, the rule reads the process’s own forming radius live and the row says = forming default; ticked, it is an explicit floor, seeded at that radius and then relaxed downward.
• Fits extent has a shape picker — disc with a ⌀, or rect with a width and a height — and a margin, all in µm.
• Allowed depths opens an indented list of intervals, one row each: a min, a max checkbox that closes the interval (unticked, the row reads open), the max field when closed, and a trash. The + below adds an interval. An empty list checks nothing.
• Allowed depth increments starts with a picker for how your shop produces the material between two depths. From stock opens an indented list of the thicknesses you buy — one µm field and a trash per row, + to add one — and a step is fine when it can be stacked from them, in any combination and with repeats. An empty list checks nothing. At least is the other shop: you make the slice rather than buying it, so the row takes a single µm field and any step at or above it passes. Switching carries your number across.

Every number here can be dragged as well as typed. A drag previews as you go and commits as one undo step when you release, and the Problems section catches up at that point rather than on every tick of the drag.

Editing a process no stack is built with rebuilds nothing — it is still a design edit, and it still costs an undo step.

See also

• Layers, stacks & processes — what a process is and what it holds.
• Deliverables — what each artifact in the list is, and when to publish it.
• Design rules — what each rule in the deck measures.
• Stack window — where a stack and its layers pick the process they are formed with.
• Problems — the report the deck drives.
• Export — where compensation and the published deliverables are stated.

Stack window

The Stack window is where a stack is authored: how many layers it has, how thick each one is, what it is made of and how it is formed. It opens from Design → Stack… or from the pencil in the Layers section, and like the Fab processes window it floats over the layout, leaving the design editable underneath.

It edits whichever stack the strip shows, which need not be the active one, so you can shape a production stack while a prototype one drives the viewport. Every value here is a design edit and one undo step; an edit to a stack that is not active changes nothing on screen until you make it active.

The stack strip

The picker lists the design’s stacks, and choosing one says which stack the rows below edit. It does not make that stack active, and it costs no undo step.

+ adds a stack by duplicating the shown one. The trash removes it, and is refused twice over: a design keeps at least one stack, and the active stack cannot be removed. Make another active first; the tooltip says which of the two applies.

The row underneath either shows the ● active marker or offers Make active, which switches the viewport to this stack. The name field beside it renames the stack on Enter or focus loss.

The stack’s own rows

base layer is the layer of this stack the open component anchors at — its layer 0 sits there. The list spans this stack’s own layers, so the pick is always in range.

fab process names the process this stack’s layers are formed with, chosen from the design’s pool. It is the default every layer inherits, and it decides which wall kinds can be formed, which design rules are checked, and what export writes. Editing the process itself is the Fab processes window’s job.

registration is how the layers are located against one another, and the picker offers Common datum, Sequential · RSS and Sequential · worst case. See Layers, stacks & processes for what each one does.

The layer rows

There is one row per layer, the top of the stack first and the substrate last: a swatch in the layer’s viewport color, shaded by its default face, then Layer N, then a delete at the right end.

Clicking the label opens that layer’s detail underneath it, and clicking it again closes it. This is the window’s own selection and has nothing to do with the active layer.

The delete is refused for the last layer — a stack keeps at least one — and for a layer carrying content, which has to be emptied first. Only the active stack has the design built onto it, so on any other stack only the last-layer rule applies.

Add layer at the foot adds one on top, as a copy of the topmost slab.

A layer’s detail

The detail is a grid of labeled rows: thickness, face, depth, walls, process, material and bond below.

thickness is the slab’s own thickness, in µm. Drag it and the viewport follows; release to commit.

face is the side features are cut in from by default, Top or Bottom, and depth is how far in, in µm. Both are defaults the children on this layer inherit and may override.

walls is the default wall profile, and its kind list is only what the process forming this layer can form. Under a per-layer override that is the layer’s own process, not the stack’s. A stored kind the process cannot form still shows as the selection; see Design rules for what the report says about it.

Beside the kind sits its parameter, in µm radius or ° draft. While it is unset the field shows the process’s forming value dimmed, marked · process, so it follows a later process edit. Typing or dragging a number overrides it, and the ✕ that appears removes the override again.

process is the layer’s own forming process. Its first entry is inherit, and it names what it inherits (inherit (soft-lithography)), so an unassigned layer still says which process forms it. Picking a pool process instead is how a laminated film sits over a molded body in one design. It moves the wall list above, the rules that layer is checked against, and what export writes for it.

material identifies the layer’s material by number, with a backing checkbox that reveals a second one: a laminate backing slab of that material filling below the deepest feature.

bond below is the alignment tolerance of the joint between this layer and the one under it, in µm align. Layer 0 has nothing under it, so its detail has no such row.

See also

• Layers, stacks & processes — the stack, the bond, faces, depth and the roof.
• Fabrication overrides — how a child departs from the defaults this window sets.
• Layers — the panel section that picks the active stack, the anchor and what is visible.
• Fab processes window — where the processes these rows choose from are authored.
• Export — what the stack’s layers produce as files.

Export

File → Export Fabrication Files… opens one dialog over the whole fabrication package. The package is the unit you hand a shop, so there is no per-format submenu.

The center of the dialog is the list of files it would write. That list follows the design as it stands, and the Export button writes exactly those files.

The dialog does not remember what you set — what is ticked, the version, the folder, the name. Each time it opens, the version is R2000 again and the rest come from the document: every deliverable that can be written ticked, the design’s own folder, and the file’s name with the open component’s as the base.

The target line

The target line at the right under the heading, Component: Chip · Stack: substrate, names what these files fabricate. Export writes what the viewport shows, so the component is the one you have open and the stack is the active one.

Opening a component and exporting fabricates that component, whether it is the design’s root or a subassembly of it. Where it is not the root, a warning-colored not the root component (Chip) trails the line, naming the root you did not export.

A process block

There is one block per process forming a layer of this stack, headed with its name and the layers it forms — soft-lithography · layers 0–2. A stack whose layers all inherit one process has a single block.

The block holds a checkbox per deliverable that process publishes, with the file format at the right of its row. Under each checkbox are the files it would write, grouped by layer. The names follow one pattern, chip-Chip-layer1-mask50.dxf: the base name, the layer, and what the file is. The layer is the number the Layers section shows, so a file matches its slab by name. A mask set gives one file per distinct depth in a layer; cut contours give one per sheet; a secondary-op table gives one -ops.csv per layer with holes to cut. See Deliverables for what each writes.

After assembly

Below the process blocks, a section headed After assembly · the bonded stack appears when any process in the stack publishes a deliverable of the finished part rather than of a sheet. Today that is the secondary-op table: holes drilled after the layers are bonded are one operation on the whole device, so they belong to no layer and no process. Its checkbox is ticked once for the stack, and the file it writes is named chip-Chip-assembly-ops.csv.

The section is absent when nothing publishes such an artifact, and it plans no file when nothing in the design is cut after bonding.

A file already sitting in the folder is marked overwrite on its row. There is no second confirmation behind it.

A deliverable this version cannot write yet keeps its row, disabled and marked not exported yet. A process that publishes nothing gets its block anyway and says so.

The line closing each block is that process’s compensation: whether it is characterized, and at what scale. You cannot change it here — compensation is authored on the process — and it matches the sentence the exported files carry.

A layer carrying blind features on both of its faces is not exported yet, and says so in warning color under the blocks: Layer 2: blind features on both faces are not exported yet.

The package statements

No files: names the layers the package leaves without one, and why each is silent — No files: layers 1–2 — nothing ticked for ‘soft-lithography’. A featureless slab is not listed at all, since a blank lid produces no file, and neither is a layer whose only ticked deliverable legitimately has nothing to say about it — that reads what is ticked for ‘soft-lithography’ produces no file for it.

Leftovers from an earlier export under this base — a mask for a deliverable since unticked, a depth since changed — are listed under a warning line. One checkbox, Move into superseded/, governs the lot. It is ticked by default, and nothing is deleted: each file moves one folder down.

Version, folder and name

DXF version is R2000 or R12. The line under it states the units the files are in, and it changes with the version. R2000 files state their own units, and the line repeats that. R12 has no way to state units in the file, so the line is the only statement of them and it tells you to confirm with your shop.

Folder shows where the package goes, with Browse… for your system’s folder picker. Base is the file-name stem every name in the list is built from, committed on Enter or focus loss — change it and the whole list renames. It opens as the file’s name and the open component’s, chip-Chip. Two components exported into one folder then keep distinct names, so neither reads as the other’s leftovers (→ The package statements).

Outstanding problems

A design with open design-rule findings still exports. The dialog states the count in warning color — 2 DRC errors outstanding, the same findings the Problems section lists — and does nothing else about it. A clean report shows no line at all.

The Export button

The button carries what it will do — Export 5 files · set aside 3 — and is enabled while there is either a file to write or a leftover to move. With nothing ticked and a clean folder it is disabled.

A completed export closes the dialog and leaves a note on the status bar saying how many files went where.

A failed write keeps the dialog open behind the file-error report, so you can point it at another folder and try again. A leftover the tidy-up could not move is reported in that same status note and not as a failure: the package was written.

Cancel, Esc, or a click outside the dialog closes it without writing anything.

See also

• Deliverables — what each artifact is, and how a mask set and cut contours differ.
• Layers, stacks & processes — the process a deliverable and a compensation belong to.
• Fab processes window — where compensation is authored.
• Stack window — where a layer’s forming process is assigned.
• Design rules — what the outstanding counts are counting.
• Menus & files — the File menu this dialog opens from.

Menus & files

Five menus sit at the top of the window. The first three act on the document — File, Design and Edit — View switches what you are looking at, and Help changes nothing in the document. Every item that has a shortcut prints it on its own row. Shortcuts are inactive while you are typing in a text field.

File

New (Ctrl+N) replaces the open document with a fresh one: one empty component named Chip, already the root, over a single patterned slab. The slab is a stack named substrate, formed by a process named soft-lithography. Both names are yours to change, in the Stack window and the Fab processes window.

Open… (Ctrl+O) and Save (Ctrl+S) / Save As… (Ctrl+Shift+S) use your system’s own file dialogs, filtered to Experiware designs with an all-files option. Save on a document that has never been saved asks for a path first. Save As starts in the current file’s folder, offering the document’s name.

Export Fabrication Files… opens the export dialog, which is where the files a process would publish are listed and written. The item never grays out: a stack whose process publishes nothing is explained inside the dialog.

Design

Fab processes… and Stack… open the two fabrication editors — the same windows the toolbar’s Fab processes button and the Layers section’s pencil open. See Fab processes window and Stack window.

Edit

Undo (Ctrl+Z) and Redo (Ctrl+Y, or Ctrl+Shift+Z) each name what they would act on: Undo Draw Channel, Redo Set Depth. With nothing to undo the row reads a bare Undo and grays out.

One gesture is one step. A channel drawn through four bends, the points it created at its ends, and the drag that positioned a freshly placed component all undo as the single act you performed. Selecting is not an edit and has no step of its own.

While the cursor is in a text field, Ctrl+Z undoes your typing in that field instead.

View

2D top-down and 3D orbit pick the view, with the one you are in marked. Tab prints on the row you are not on: the key toggles, so it always takes you to the other one. The toolbar’s 2D/3D pair is the same switch. See Viewport & navigation.

Help

User Guide (F1) opens this guide in your browser. It is the copy that ships beside the application, so it works with no network. A copy whose guide folder is missing says so on the status bar rather than opening nothing.

Check for Updates… asks now instead of waiting for the next launch, and answers either way. A newer release raises the update banner. If you are on the latest, or the server could not be reached, the answer is a note on the status bar. It runs even with the startup check switched off. What the check sends, and where that switch is, are Settings → Updates.

About Experiware names the build you are running, where to write, and the folder crash reports are written to. Quote the version when you report a fault.

The window title

The title bar reads Chip — Experiware: the document’s name first. A leading • means there are unsaved changes.

The marker follows the edits themselves: undo back to the point you last saved and the dot clears, redo away from it and it returns.

Unsaved changes

New, Open and closing the window all discard the open document, so each asks first when there is something to lose. The question names the document and offers three answers: Save saves and then continues, Discard throws the changes away and continues, and Cancel abandons the command. Dismissing the dialog with Esc or a click outside it counts as Cancel.

Save only continues if the save succeeds. Dismiss the path picker, or hit a failed write, and the command is abandoned instead, with the changes you asked to keep still there.

Design files

Designs are .exw files, and one format covers both roles. A design and a component library are the same kind of file, so a file you author can be placed by another design without converting anything.

When you open a design, Experiware also scans the folder it came from and loads every sibling .exw that declares a library identity — that is how those components reach the Libraries tab. A sibling that cannot be loaded, or one that changed since your design pinned it, is reported as a library warning on the status bar; your design still opens. A failure inside a library your design actually uses is fatal, and the open is refused.

A failed open or save raises the file-error report: the headline, the path, and the message from the file itself, which for a malformed design names the line and column. The document you had open is untouched.

A design that loads but does not resolve is a different case and is not a failure: it opens, and the reason appears in red under the inspector’s header, where you fix it.

Crash reports

If Experiware crashes it writes a report first: which build you were running, your platform, what failed and where. Reports are written to crashes under %LOCALAPPDATA%\Experiware — the folder the About box states — and accumulate instead of overwriting each other.

The design you had open is not saved along with it, so a crash costs you the unsaved changes the title bar’s • marked.

See also

• Components, parameters & pins — what a component definition is, and what the root component means.
• Components & Libraries — the browser those sibling files appear in.
• Window & panels — where the menu bar and the status bar sit, and the update banner below them.
• Settings — the update check’s off switch, and where your preferences are kept.

Settings

Settings are how you author and view, not part of what you are designing. They are never written into the .exw file and never appear in undo. One set covers every design you open, and it is kept between sessions.

They appear in two places: the quick strip at the top of the left panel, and the Settings window behind its gear.

The quick strip

Grid shows or hides the grid overlay, and Snap turns grid snapping on or off. Both light while they are on.

The gear opens the Settings window, and a second click closes it again.

The Settings window

The Settings window floats over the layout and carries every setting. Close it from the gear or from its own ✕.

Grid

Show grid and Snap to grid are the strip’s two toggles under their full names.

Pitch is a single value in µm doing both jobs: the spacing of the fine grid lines and the lattice a snap rounds to. Every tenth line is drawn brighter, and the drawn lines thin out by tens as you zoom out while the snap keeps the pitch you set. Drag the field to scrub the value or type one and press Enter; it will not go below 1 µm.

The lattice is measured from the world origin rather than from your design. In 3D the grid is drawn on the active layer’s plane, and it moves when the active layer changes.

Viewport

Inactive layer mute sets how far the layers that are not the active one desaturate toward gray, from 0 (every layer at full color) to 1 (inactive layers fully gray). The viewport follows the slider as you drag it. The active layer is always vivid.

Openings chooses how the holes through the chip are drawn — the punches under your world ports and the vias between slabs (Viewport & navigation).

• Narrow is the default: a thin shaft on the bore’s axis. A punch is around a millimetre across and the channel it lands on is a fraction of that, so drawing it at size hides the network you are working on.
• True diameter draws each bore at the size it will be cut. Use it to read clearances — how close a punch comes to a neighbouring feature.
• Hidden draws no bore at all.

The setting changes only what is drawn. The openings themselves are worked out from what you connected, and they are the same at all three.

Updates

Check for a new version at startup is on by default, and the dim line under it states what the check sends: your version and your operating system, nothing else. That request is the only thing Experiware sends anywhere.

The automatic check runs once a launch, in the background, and stays quiet unless there is something newer — a failed check says nothing, because you did not ask. When it does find a release, the update banner appears under the menu bar. Help → Check for Updates… asks on demand, reports either way, and runs even with this checkbox clear (Menus & files).

Grid snapping

Snapping applies wherever a gesture sets a position: moving a child, placing a point or a component, and each vertex you place while drawing a channel or a region. The position rounds to the nearest grid intersection.

Hold Ctrl to invert the setting for that one gesture — with snapping on it moves freely, with snapping off it snaps.

Preferences that live elsewhere

Two more settings behave exactly like these but sit where they are used: the explode gap, on the Layers section, and the default channel width, in the toolbar’s Draw channel options.

The two panel widths and the section heights you drag to are stored the same way, which is why a layout survives a restart (Window & panels).

The preferences file

Everything on this page is written to settings.json under %APPDATA%\Experiware, and read back at launch. The write follows the change rather than waiting for you to quit, so a session that ends badly still leaves your settings behind.

Delete the file to return every setting to its default. A file that is missing, unreadable, or written by a different version is not an error: whatever cannot be read falls back to its default.

See also

• Viewport & navigation — the grid, the two view modes, and what the mute changes.
• Layers — the explode slider and the active layer the grid follows.
• Window & panels — where the quick strip sits in the frame, and the update banner the check raises.
• Menus & files — the Help menu’s on-demand check, and the About box.

Components, parameters & pins

A design is a set of component definitions, one of which is the root — the design’s top-level component, and the one the file opens at. Everything you draw lands in the body of some definition, so a chip authored as a single flat drawing is one definition whose body holds all of its channels, points and regions.

Export fabricates whichever component is open, not the root, so a subassembly opened on its own exports as a device in its own right. See Export for the dialog and what its files are named.

Component definitions and placements

A component definition is a template. Placing it inside another definition’s body creates a child that refers back to it, so editing the definition updates every placement of it at once.

Two placements of one definition are independent children. Position (pos), rotation (rot) and layer belong to the placement; the shape belongs to the definition. The viewport marks a placement’s position with an amber diamond while you hover or select it. Each placement also sets its own args: one value for each parameter of the definition. An argument you leave unset falls back to the parameter’s default.

Composition runs one way: a component cannot place itself, directly or through a chain of others. A placement that would close such a loop is refused at the moment you make it.

Deleting a definition is refused while it is the root, and while another definition places it.

Parameters

A parameter is an input to the definition — what someone placing it can set. It has a name, a type, and usually a default.

There are four types:

• Number — a plain real value; where one is a length it is micrometres, and where one is an angle it is radians.
• Int — a whole number, for counts such as the turns in a meander.
• Vec2 — a pair, read with .x and .y.
• Bool — true or false.

A parameter with no default reads (required), and every placement of the definition must supply an argument for it.

Computed values

A computed value is a name bound to an expression over the component’s parameters and its other computed values. Use one to state a relationship once — a chamber’s area from its width and length, a meander’s total length from its pitch and turn count — instead of repeating the arithmetic at every child that needs it.

Its type follows from the expression rather than being declared, so you never set it.

The expression language

An expression computes a value and does nothing else. There is nothing to assign, no loops, and no functions of your own.

Numbers carry units. 250um, 0.5mm, 2cm, 800nm, 45deg and 1.2rad are all literals; the suffix folds to micrometres or radians, so 0.5mm and 500um are the same value. pi, tau and e are constants.

Operators are arithmetic (+, -, *, /, %), comparison (==, !=, <, <=, >, >=) and boolean (&&, ||, !). Division always produces a Number, so 3 / 2 is 1.5.

Conditionals are written if cond then a else b, and both arms must have the same type.

Functions are a fixed set: vec2, min, max, abs, clamp, sqrt, pow, floor, ceil, round, sin, cos, tan, atan2. A name counts as a function only when a ( follows it, so a parameter may be called min without shadowing anything.

An expression sees the parameters and computed values of the component it is written in, and nothing else — not a child, not a sibling, not the component that placed this one. Values travel downward, through arguments.

An expression that does not parse never takes effect. One that parses but does not type-check leaves the component unresolvable until you fix it. See Inspector for where the reason is shown.

Pins

A pin is a connection point a component exposes to whoever places it, and pins are the only part of it another component can attach to. A channel in the parent attaches to a pin; everything behind the pin stays inside the definition and changes with it.

A pin is made by exposing a terminal — a point, or a pin of a component you placed. Exposing a point in the body publishes that point; exposing a placed component’s pin forwards that pin outward under the same name. Every terminal draws as an amber circle, a point and a placed component’s pin alike, and an exposed one takes a sky-blue ring around that circle. Unexpose removes one. See Inspector for the controls.

A pin’s name is separate from the label of the point behind it. The two start equal and the inspector shows one name while they are, so they diverge only when you rename the pin deliberately. Renaming or deleting a pin is refused while another component refers to it.

World ports

A terminal marked world port is open to the outside: an inlet or an outlet. The viewport badges one with a burst of short rays around its circle. Every other terminal is an interior connection, sealed inside the assembled chip.

The mark sits on the terminal, not on a pin, so a point does not have to be exposed to be a port — select it and tick world port in its detail. Beside the tick you choose which face of the chip it comes out of, down by default. The port takes the terminal’s own name, so renaming the point renames the port.

The same tick is there on a terminal inside a component you placed, reached from the Body tree, which is how you open a port on a library part without editing the part.

The built-in components mark nothing. Whether a given inlet reaches the outside is decided by the design that places them, so it is a setting you make on your own top-level component.

Connections between components

Two pins never merge into one point. To join two placed components you draw a channel between their pins, however short.

A pin named by two or more channel ends is a shared junction, so you make a fan-in by pointing several channel ends at one pin.

Built-in components

Three components ship with the app:

• Serpentine — a square meander for mixing or delay, with inlet and outlet pins and a computed length.
• FlowFocusing — a droplet-forming junction: dispersed, sheath_a, sheath_b and outlet arms meeting at a narrowed orifice.
• Chamber — a rounded reservoir whose corner_radius takes it from a sharp rectangle through a stadium to a circle, with inlet and outlet taps on its wall.

Any .exw file that declares a library identity and sits beside the design you opened is a library, and its components can be placed like any other. A library component is read-only: you set its arguments at each placement as for a component you authored, but you cannot edit the definition. See Components & Libraries for what opening one shows.

See also

• Inspector — the Params, Computed, Pins and Body tabs that edit everything on this page.
• Channels & points — the terminals a pin is exposed from.
• Components & Libraries — the browser the built-ins and library components are placed from.

Channels & points

Points and channels are what a fluid network is made of. A point is a terminal — a place a channel can end. A channel is the connection between two of them.

A channel always ends at a point. A junction is a point that several channels share, and a chamber is reached through a point riding its wall.

Points

A point is a position and a set of properties, and it fabricates nothing on its own, so it draws in the viewport as a marker — a small amber circle — and not as geometry.

A point carries a width. Channel ends connected to it inherit that width, so a run through a point stays one width and editing the point moves every inherited end together. An end that sets its own width overrides the point’s, which is how you author a taper or a junction arm narrower than the run it leaves.

A point also records an offer — how many layers it can be connected from, counting up from its own layer row. A plain point offers 1 layer, its own; raise the count and channels on the slabs above may connect to it too, which is how a via is drawn. Tick all instead and it offers every layer of the stack, including ones you add later.

The offer says what is possible, not what is there. What a point actually joins comes from the channels and regions that connected to it, so a point offering three layers with one channel on it is an ordinary point. A point on a layer it does not offer is simply not a target there: the rubber band passes over it without snapping, and a release drops a fresh point instead. Narrowing an offer with a channel already attached is fine too — the channel stays exactly where it is, and the point stops advertising the layer.

A terminal inside a component you placed offers what its author drew, and you can override that from your own design without editing the component: select the pin in the Body tree and tick its offer row. Beside the layer count there is a floor, which the point’s own layer row plays for a point — set it to -1 to route a slab under the component. Both are relative to the terminal, so moving the component moves the whole range with it and nothing you typed changes.

A free point sits where you place it and accepts any number of channels. A wall-bound point rides one edge of a sibling region’s wall and accepts at most one, since it is a break-in through that wall. Binding is a property of the point, not of the channel: a channel adopts either kind the same way, and either can be exposed as a pin.

Channels

A channel is one connection, whatever shape it takes. A long run with five bends between two junctions is a single channel: one row in the Body tab, one thing to select, name and delete.

Its shape is a centerline polyline: the two ends, plus the interior vertices you place between them. The ends are anchored to the points they connect. The interior vertices are geometry, and deleting one straightens the channel through it. Selecting the channel puts a mint-green square handle on each of them, which is how a vertex reads apart from the amber circle of a point.

Width is a value at each vertex, interpolated between them. Give the two ends different widths and the channel tapers along its length; give an interior vertex its own width and the taper turns there. An end with no width of its own inherits from its point.

Channel ends

An end attaches to a pin or a point — either one you already have, or one the drawing gesture creates for you where you finish. Ending on the body of another channel splits that channel and puts a new point between the two halves. See Toolbar & tools for the four ways an end resolves and what each one creates.

Bends and junctions

Several channel ends may name one free point, and that point is the junction — a T, a cross, or the four-armed node inside a flow-focusing component. Two separate points never merge into one, so a junction exists only where channels share a point you placed.

An interior vertex is a bend rather than a junction, and nothing can attach to it. Promote to point on the right-click menu turns one into a junction, splitting the channel there into two channels meeting at a new point. Dissolve into channel is the reverse: a point where exactly two channels meet collapses back into a single channel through it, and the item is disabled with a reason where the point does not qualify.

Neither changes the fabricated shape. A point where two channels meet straight through is mitered as the bend it replaced was, so you can promote a bend and dissolve it again without altering the geometry.

Region-wall landings

A channel reaches a chamber or a reservoir by ending at a wall-bound point, which rides one edge of that region’s wall. The channel breaks through the wall there, and the two shapes meet along an exact stretch of the edge with no material between them.

A landing has to fit the wall it sits on. It keeps at least half the channel’s width clear of each corner, sliding along the edge so the opening never runs off its end. A wall edge shorter than the channel is wide takes no landing at all.

A wall-bound point with no channel on it is a wall tap — a marked landing spot that opens nothing. Built-in components expose their taps as pins, so a chamber has inlet and outlet already placed on its wall, and the wall stays closed until you connect something.

Openings

An opening is the hole that gets the network out of its slab. It is one construction with three uses, differing only in what the two ends are:

• A via joins a channel on one layer to a channel on another, through a point they share.
• A world port joins a channel to the outside, through the face of the chip you chose.
• A well opens a chamber or a reservoir to the outside, through a wall tap you marked as a world port and left unconnected.

There is no via tool and no well tool. You draw the network, mark what should reach the outside, and the openings follow from that.

An opening is derived, never drawn. A point forms one when what connects to it — its channels, plus the region a wall-bound point rides — sits on two or more slabs, or when you tick world port on it. A port you marked before drawing anything forms nothing: an opening joins two things, and one end would have nothing to join.

What it removes is decided per slab. Every layer between the two ends is cut through, except one whose feature already opens toward the hole, where there is nothing left to take. Two channels on neighbouring slabs facing each other are the case where that leaves nothing at all: they already meet across the bond, so the opening is real and no tool is needed for it.

Openings draw as shafts in the viewport (Viewport → Openings), and they are never geometry in a mask or a cut contour. They export as rows in a secondary-op table instead, because a hole is a call-out — where, which tool, what size — rather than a shape.

Sizing the hole

A terminal’s bore rows say how the opening it forms is cut: the punch size, the operation, whether it happens before or after the layers are bonded, and the pad. They are a conditional setting — they describe the opening this terminal would form, so they stay editable on one that forms none, and the detail says so above them. Unticked, each row falls through to the process the stack is built with. See Inspector for the rows and Fab processes window for the shop defaults under them.

See also

• Regions & compartments — the walls a channel lands on.
• Components, parameters & pins — how a point becomes a pin.
• Inspector — the ends block, the vertex detail and the point detail.
• Toolbar & tools — the Draw channel, Add point and Insert vertex tools.
• Deliverables — the table an opening is exported in.

Regions & compartments

A region is an area cut into one slab: a chamber, a reservoir, a well, a mixing cavity. It has no route and no ends, and a channel reaches it by landing on its wall.

Compartments

A region is divided into compartments, and the compartment is what you select, name and edit. A newly drawn region holds one compartment, which is the region itself. Divide the region and each piece gets a row of its own.

A compartment is filled with either void or material:

• A void compartment is a pocket: the slab is carved away there and the fluid is in it. A pocket carries its own depth, wall profile and corner radii, so one region can hold a shallow antechamber beside a deep well, or a step in a chamber’s floor.
• A material compartment is a hole: the slab is left untouched there and the fluid is not in it. Use one for a post standing in a chamber, an island, or a wall between two halves of one shape.

Switching a compartment’s fill turns one into the other. A pocket switched to material becomes a hole and the slab closes over it; a hole switched back is carved out again. Material inside material is not a state the slab can hold, so that direction is refused. See Inspector for the fill control.

Nested shapes

Drawing inside a compartment produces its opposite. Inside a chamber you draw a hole, an island of slab standing in the void. Inside that hole you draw a pocket, a void carved into the island. You can go on nesting as deep as you need.

A pocket drawn inside a pocket is not separated from it. The two meet along their shared boundary and form one void that differs only in depth, so separating a void from the void around it takes a hole between them.

The weld

Welding joins the shape you are drawing to one that is already there: place a vertex on an existing wall and the two shapes share that boundary exactly, with no material between them. Two shapes drawn separately land their vertices a fraction apart, leaving a thin wall you did not ask for.

A welded shape can take a run of the wall it welds to along with the boundary, which is how a corridor comes off a chamber. See Toolbar & tools for the clicks that decide how much of the wall comes along.

Seams and movement

A seam is the boundary two welded compartments share, and the app draws it as a hairline. It is the one part of a compartment’s outline that fluid crosses.

Welding also merges the shapes into one movable unit, so dragging a welded compartment brings its neighbours with it. A shape set inside another, such as a hole in a chamber or a pocket in a hole, is not welded to it and moves on its own.

Welding onto a region that is a separate child absorbs it: its shape joins the one you drew, and it stops being a child of its own. Absorbing is refused where it would discard something you authored, such as a position bound to an expression or a label a pin sources, and the chip says which.

Compartment removal

Deleting a compartment removes that piece of a divided region, and the whole shape where the region holds one compartment. It is refused while a channel lands on that compartment’s wall, since the landing would have to move to a wall you did not choose.

Deleting a piece is also how you put a wall across the top level of a region, where a hole cannot go. Carve a chamber into three pieces, all of them pockets, and delete the middle one: the slab closes over it and leaves the two ends separated. One tier down, inside a pocket, that wall can be a hole with a row of its own instead.

Compartment names

A compartment with no name of its own shows a derived one: region for the compartment that is the region, and hole 1, pocket 2, hole 3 numbered among its siblings. Those numbers are positional, so removing a sibling renumbers the rest. Name a compartment where you need the label to stay put.

Placement

The outermost compartment carries the region’s own pos, rot and layer, so moving the region moves everything inside it. A nested compartment carries dx, dy and rot instead, which move it within the shape that contains it. A nested compartment has no layer row, since everything in one region is cut into one slab.

Regions in the network

Channels reach a region only through wall-bound points. A region with none on it is a cavity in the slab that nothing flows into.

See also

• Channels & points — wall-bound points and how a channel breaks into a wall.
• Inspector — the fill control, the compartment detail and the Body tree.
• Layers, stacks & processes — the slab a region is cut into.
• Fabrication overrides — the depth, walls and corner radii a pocket carries.
• Toolbar & tools — the Draw region gesture, and the wall clicks a weld is made with.
• Keyboard & mouse reference — the Draw region tool’s keys.

Layers, stacks & processes

A design is drawn as components and made as a stack of bonded slabs, each formed by a process.

The stack

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

Only the layers you pattern belong to the stack. The glass slide a PDMS chip is bonded to carries no features of yours, so it is not a layer — a typical soft-lithography chip is a one-layer stack, with the glass understood to sit against the face the channels open onto. Add it as a layer only if you need to cut something into it.

Each layer carries:

• Thickness.
• Material, with an optional laminate backing — a second material filling the space below the deepest feature.
• Default face, depth and walls — what the features cut into the layer inherit.
• An optional process of its own, which overrides the stack’s.

A bond sits between adjacent layers and carries the alignment tolerance of that joint. The stack’s registration scheme says how those tolerances accumulate. 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.

Faces, depth and the roof

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

The material left between a feature and the opposite face is the roof, thickness − depth. A thin roof sags shut in a soft material, so the design rules measure the roof directly. 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 a face closes it into a conduit — the neighbouring layer’s, or that of a cover the stack does not model.

Draw on the Top face

Both faces work, and each feature says which one it is cut from. Draw on Top wherever you can: it is what a new layer defaults to, and the viewport is opaque, so a feature cut from Bottom lies under its own roof and the layer looks unbroken from above until you explode the stack. Much of the app is tuned for Top and more of it will be. How many faces one layer may use at all is the process’s to say — a design rule reports a layer that opens from more faces than the process can form.

The convention puts the cover above your layers, so the exposed outside face is the bottom of the stack. A PDMS chip is one layer whose channels open upward, with the glass understood to sit on top of it; a Quake device is two layers — control at layer 0, flow at layer 1 — with the glass above both. A finished PDMS chip is normally held glass-down, so the viewport shows it the other way up; your design and the files you export are the same either way.

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 open component anchors at. It is a design edit and not a view setting, and the viewport always shows the design at that anchor.

Beside it, the active layer is view state: it is where a newly placed child lands. 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 data you author, and it holds:

• Deliverables — the artifacts this process hands a shop, which export writes. See Deliverables.
• Compensation — the measured shrink of this process, and the scale export derives from it 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. See Fab processes window for the shrink you author and the scale it derives.
• 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.
• 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.
• 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.

A change of process

Switching a layer’s process rewrites nothing you have drawn. The outlines, centerlines, widths and depths stay as you authored them, and a process your design violates is not refused: the model goes on building, and the Problems section says what that process cannot form.

What does follow the process is what you left inherited. Corner radii come from the process, as does a wall parameter you have not set, so the same drawing is formed at one fab’s radii and then at the next one’s. Override a value and it stays where you put it.

See also

• Deliverables — the artifacts a process publishes, and what each one is.
• 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.

Fabrication overrides

Most of a feature’s shape comes from around it: a channel’s depth from the layer it is drawn on, a corner’s radius from the process forming that layer. An override is a value you set on one child instead, and every override works the same way.

Inheritance and overrides

Every fabrication value is either inherited or the child’s own.

An inherited value tracks where it comes from, so a later change to that layer or process follows through to the child. An overridden value is the child’s own and stays where you put it. Taking one over starts it at the value it replaced, so nothing moves until you edit it. Clearing it returns the value to tracking what it inherits.

A child sitting off the stack has no layer to inherit from, so face, depth and walls have nothing to track there. Overrides already on it stay editable and removable.

See Inspector for the checkbox that switches between the two.

Which children carry overrides

Void compartments, channels and points carry fabrication values of their own. A material compartment carries none — untouched slab has no face, no depth and no walls to state.

Face, depth and walls

These three inherit from the layer.

Face picks which side of the slab the feature is formed from. It is set on the child as a whole, since every part of one child opens from one side.

Depth is in micrometres, measured in from that face. It is what makes a chamber deeper than the channels running into it, or a pocket a step in that chamber’s floor.

Walls is the wall profile: Vertical, Fillet with a radius, or Draft with an angle in degrees. The kind and its parameter are overridden independently, and only Fillet and Draft have a parameter to set. Leaving that parameter unset means the process’s forming default, and it follows a later process edit instead of freezing at the number that was there when you chose the kind.

A wall kind the layer’s process cannot form is not refused. The geometry builds and the Problems section reports it.

Corner radii

A drawn corner is infinitely sharp and no instrument cuts one, so every in-plane corner is formed at some radius. Radii come in two classes: inner, at a corner of the void, and outer, at a corner of the material. Which class a corner takes follows from its own shape: the outside of a bend is one, the inside is the other. You set the pair rather than picking a class.

Corner radii inherit from the process rather than from the layer. Two authored tiers sit under that base:

• the element tier — a channel, a region or a point;
• the vertex tier — a channel’s interior vertex or a region’s ring vertex, overriding its element’s.

The inner and outer radii are independent. Override the inner one and the outer goes on tracking the process.

A region ring vertex is exactly one corner, so it authors one radius rather than a pair, in whichever class that corner takes. Drag the vertex from convex to reflex and the value follows it into the other class. A channel’s interior vertex and a point each form corners of both classes, so each authors the pair.

A channel end carries no corner radii of its own: its corners belong to the point it connects to, so a junction’s corners are authored once rather than once on every channel arriving there.

See also

• Layers, stacks & processes — the layer defaults and process defaults these values inherit from.
• Design rules — what happens when an override asks for something the process cannot form.
• Inspector — the fabrication group and the vertex detail.
• Regions & compartments — why a material compartment has no fabrication values.

Design rules

Experiware checks your design against the process forming each layer and reports what it finds in the Problems section. The report is live, recomputed on every committed edit. A design with errors still builds, still displays and still exports. See Export for what the dialog says about outstanding findings.

Rules are data

There is no fixed list of checks. Each process carries a rule deck: a table of rules, each with a severity of Error or Warning and, for all but Floating island, a threshold of its own. Change a threshold in the Fab processes window and the report changes with it.

A rule the deck does not carry is not checked. Silence about the roof of a molded part means the molding process carries no roof rule, not that your roofs are fine. A rigid part’s roof does not sag, so the molding deck has no roof rule to state.

Which process governs

Every finding names the process whose deck set the limit: the one governing the layer the finding is on. Under a per-layer override that is not the process you were last looking at. A finding reading wall 3 µm < 8 µm min · film tells you the film process set that 8.

What is checked

• Min feature — a void narrower than the process resolves, measured on the formed shape rather than on the width you typed.
• Min wall — a wall or gap between features thinner than the process can hold, and features that overlap outright.
• Min inner radius and Min outer radius — a corner formed below the process’s floor, measured at the radius it is actually formed at. A corner left sharp has a radius of 0 and is measured like any other.
• Max aspect ratio — a feature deeper than its own width by more than the process allows.
• Min roof — a roof thin enough to sag shut.
• Max roof span and Max roof span ratio — an unsupported roof reaching further than the process allows, either as an absolute width or as a multiple of the roof’s own thickness.
• Allowed depths — a depth the instrument cannot reach, authored as intervals.
• Allowed depth increments — a step between two depths the process cannot produce. Under From stock a step passes when the sheets you buy stack up to it, in any combination and with repeats; under At least any step at or above the one number passes.
• Max depths / layer — more distinct depths in one layer than the process forms in one go.
• Max faces / layer — a layer opening from more faces than the process can work. A through feature counts as both faces, since a through cut is worked from either side.
• Fits extent — features running outside the working area, margin included, on a disc (a wafer) or a rectangle (a platen or a sheet).
• Floating island — material fully enclosed by through-cut void, with nothing holding it.

What is not checked yet

The deck table lists every rule the app knows. Two of them take a threshold that nothing measures against:

• Min aspect ratio — a feature far wider than it is deep.
• Min secondary-op spacing — two secondary operations, such as drilled ports, too close together.

No preset enables either, and each carries a dim not checked yet note wherever it appears, so an empty report does not mean they passed. See Problems for the line the report carries when one is enabled.

The two checks outside the deck

Wall capability asks whether the process can form a wall kind at all, and it reads the process’s wall list rather than the deck. An empty wall list allows nothing, where an absent deck rule checks nothing. It is always an error, since a fab that cannot form a shape cannot form it at any threshold. A kind left stale after a stack switch is reported and never changed for you.

Structural defects are always checked and are not configurable: an outline that crosses itself, a hole outside its region, a hole touching its region’s wall, compartments that overlap or that meet without sharing a whole wall. No process forms any of these, so there is no threshold to set and no entry to omit.

Geometry already flagged as defective is not measured against the deck. A hole that escaped its region would report a wall thickness that means nothing, so you get one finding explaining the defect instead of two that disagree.

What a finding stands for

A pillar array at too tight a pitch offends in thousands of places and takes one edit to fix. A finding says how many places it stands for instead of listing them. See Problems for what the viewport marks.

Reading a large report rule by rule shows whether it is one systemic problem or thirty separate ones. Where one rule accounts for nearly the whole report, the cause is usually a wrong process or a units slip. See Problems.

See also

• Layers, stacks & processes — the process a deck belongs to.
• Fabrication overrides — the wall kinds and depths a capability violation is about.
• Problems — the section itself.
• Fab processes window — where a deck is edited.

Deliverables

A deliverable is an artifact a process hands to a shop. Each process publishes a list of them, and the export dialog writes the ones you tick for the stack you are exporting. See Fab processes window for where a process’s published list is set.

Which one you want follows from how the layer is made, not from what it looks like. The same drawing exports as a mask set for a layer patterned by exposure, and as cut contours for one built by stacking cut film.

Mask set

A mask set is one file per distinct depth in the layer. Each file holds the union of every feature at least that deep, so the masks nest: a 100 µm chamber appears in the 50 µm file and again in the 100 µm one.

That nesting is what a bottom-up master needs — coat to the next depth, expose, coat again, expose again, develop once at the end. A ridge 100 µm tall has to stand in every exposure up to its height, so a file holding only the features exactly 50 µm deep would be meaningless.

A file is named for the depth it exposes: chip-Chip-layer1-mask50.dxf. A fractional depth writes its point as an underscore, mask47_5.

Cut contours

Cut contours are one file per sheet. Every sheet is cut through, and depth comes from stacking the cut sheets: a 100 µm chamber over 50 µm channels is one sheet cut with both, over a sheet cut with the chamber alone. The sheet below the deepest feature is the backing. It is uncut, so it gets no file.

A file is numbered by its position, counted from the patterned face inward: chip-Chip-layer1-sheet1.dxf.

The same file set

The depths a mask set splits on and the boundaries a sheet stack cuts at are the same numbers, so both deliverables write the same number of files, over the same footprints. They differ in what a name means, a depth exposed or a position in the stack, and in how an island is drawn (→ Islands).

Ticking both writes both sets, which is what one layer going to two shops needs.

Secondary-op table

A secondary-op table lists the holes a shop makes after forming — punched ports, drilled vias — one row each. It is a CSV, not a drawing, because a hole is specified as a call-out: where, which tool, what size, in which setup.

Which file a hole lands in follows from when it is cut, which is the stage on its bore:

• Before assembly — the hole is punched in a loose sheet, so it is a row in that sheet’s own table, chip-Chip-layer1-ops.csv, beside that layer’s contours. A hole crossing two layers is a row in each: two sheets, two setups.
• After assembly — the hole is drilled through the bonded stack, so it is one row in chip-Chip-assembly-ops.csv, whatever it passes through. That file belongs to the device, not to a layer, and the export dialog offers it in its own After assembly section.

A hole with no way out of the finished part — a via buried between two layers — is always cut before assembly, whatever the stage says, and the bore’s stage row in the inspector shows that with its reason rather than the setting underneath.

Both files lead with # lines stating the units, the compensation, and what one row is. A layer table’s columns are the reference number, the position, the diameter, the operation and the face the tool comes in at. The assembly table adds the exterior face the tool enters, how deep it goes, which layers it passes through, and whether it breaks out the far side — a drill that stops inside the stack is a blind hole, and the depth is the number the operator sets.

Two things are left out of both, and only these two: a hole formed by the tool itself (molded in) is not a secondary operation, and two channels on adjacent layers that already meet across their shared face need no tool at all.

The diameter is never compensated. A 0.75 mm punch is the tool you own, not a boundary to correct. Positions are a different question: a layer table’s positions carry the same compensation as the contours they are cut beside, so a hole lands on its channel; the assembly table is nominal throughout, since it is measured against a finished part. Each file says which.

Part solid

The finished layer as an exact 3D solid — described but not written by this version. A process may publish it anyway. See Export for what the dialog does with a deliverable it cannot write.

What the presets publish

• Soft lithography — Mask set.
• Laser cutting and Xurography — Cut contours.
• Injection molding, Micromilling and Hot embossing — Part solid.

The last three publish only an artifact this version cannot write, so a stack formed by one of them exports no files until you tick something else. No preset publishes the secondary-op table yet — add it to a process’s list when the shop wants one.

Inside an exported file

The drawings are DXF and the tables are CSV. Coordinates are written in mm, while every length in the app is µm. R2000 states the unit in the file and R12 cannot, and the note under the export dialog’s version picker says so; a CSV has no in-file way to state units at all, so it says so in a leading # line.

The rest of this section is about the drawings.

The difference shows in a square pocket with an island of material standing in the middle. It exports as one mask file and one cut-contour file, and the two draw that island differently.

Closed contours only

Every contour is a closed polyline, and no open path is ever written. Job software reads intent from topology: a closed contour bounds a region and takes a tool offset, an open path is a literal centre-line cut.

Islands

A closed polyline states nothing about its relationship to any other one, and readers disagree about what a loop inside a loop means: three interpretations are in use, one adding every area, one alternating in and out, one counting winding.

A mask set file therefore carries no clockwise loop at all. An island — a post standing in a chamber, the middle of an O — is spliced into the contour around it by a zero-width slit, leaving one closed counter-clockwise contour per disjoint void. The area reads the same under all three interpretations.

Cut contours keep the nested ring. A cutter cuts every closed loop it is handed, so nesting says what it should: a clockwise contour inside another is an island left standing. A slit would be a cut through solid material.

Each file states which of the two it is, in the note under the drawing.

Drawing layers and notes

Geometry goes on a drawing layer named for the artifact, MASK50 or SHEET2. The statements go on a layer named NOTES, below the geometry, where they cannot be mistaken for a contour. Every file carries its process’s compensation statement and the sentence saying how to read its contours.

Rounded corners are written as true arcs rather than as short segments, so the radius in the file is exact.

See also

• Layers, stacks & processes — the process that publishes deliverables.
• Fab processes window — where the published list is ticked, and where compensation is authored.
• Export — the dialog that writes the files.
• Stack window — where a layer’s forming process is assigned.

Keyboard & mouse reference

Keyboard shortcuts are inactive while you are typing in a text field. The status bar at the bottom of the window always shows the interactions available in the current mode.

Tools

Single-click a toolbar button (or press its key) to use a tool once — it reverts to Select after one completed action. Double-click the button to latch it for repeated use.

One region tool draws everything, and where you press decides what you get: empty space draws a new region, inside a chamber draws a hole, inside a hole draws a pocket. Placing a vertex on a wall welds to it. The chip at the cursor names what the release will make, or why it will not. See Toolbar & tools for the welding clicks and Regions & compartments for what a weld is.

View

Editing

Files

Mouse