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 — and 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 (soft lithography or injection molding) with its capabilities and design rules. Rule violations are reported live in the Problems panel while 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 panel.

New to the app? Start with A first look, then build something in Tutorial: your first chip. The Interface reference covers every surface of the app, and Concepts explains 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 Experiware window on the starter sample, in the 2D top-down view with nothing selected

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, which is how a port reads 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 zones: 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. Window & panels is the full account.

The two views

Experiware opens in the 3D orbit view, where the slabs are drawn with their depth — a channel is a trench, and a chamber has a floor.

Right-drag orbits, scroll zooms on the cursor, and middle-drag pans. The camera never sits on the left button, so it stays available whatever tool you pick. Press F to frame the whole design again after roaming.

Press Tab for the 2D top-down view. That is the authoring view: the grid is square to it and every shape reads at true position and size. Each view keeps its own camera, so Tab twice returns you to where you were.

The selection

Left-click a channel. It lights in the viewport, the inspector’s lower zone fills with its detail, and the matching row scrolls into view in the inspector’s Body tab. The panel and the canvas are two views of one selection, so clicking either is the same act.

Click inside the collection chamber and you select the compartment you pointed at rather than the whole region — a click takes you into a shape. Esc steps back out one tier at a time, and a click on empty space clears the selection.

Hovering names what is under the cursor on a small chip beside it, so you can read the design without changing anything.

The layers

The Layers zone 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. Click Layer 1 to move the emphasis, which changes nothing in the design.

Drag Explode and the slabs separate along the stack axis. Slabs are drawn opaque, so that gap is how you see a buried layer. The checkbox at the end of a row hides that layer outright.

The report

The Problems zone is the live design-rule check, recomputed after every edit. The sample is clean, so it reads no problems, over a dim line naming the rules the process asks for that are not measured yet. Nothing here blocks you — the report states what it found and leaves the work to you.

Where to go next

Tutorial: your first chip — build a small design from an empty document.
Interface reference — every surface 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

A chamber with a channel into it and a channel out of it, drawn from an empty document in about ten minutes. It uses only the drawing tools, and every surface it names has a reference page of its own.

1 · A new design

File → New (Ctrl+N). If the open document has unsaved changes, answer the question first — Discard is the right answer here.

You get the smallest design that resolves: one empty component named Chip, already the root, over a two-slab soft-lithography substrate. Layer 0 is a 100 µm slab patterned 40 µm deep; layer 1 is the cap bonded over it. Layer 0 is the active layer, so that is where your shapes will land.

Press Tab for the 2D top-down view if you are not already in it. Draw in 2D — the grid is square to it, and every shape reads at true size.

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 · 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.

Release, and you have 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 zone shows its detail. The fill control there reads void — the fluid is inside it.

The chip beside the cursor names what the release will make throughout the gesture, so a refusal is never a surprise. See Regions & compartments.

3 · 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 — and it fabricates nothing on its own, so it shows as a marker rather than as geometry. It arrives 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 · 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.

Two things happen at once. A wall-bound point is created on that edge — labelled p — and the channel ch connects your inlet to it, breaking through the wall there. The whole gesture is one undo step, so Ctrl+Z takes back the channel and the point it made together.

A channel end resolves four ways, in order: a pin or a point, another channel’s body, a region’s wall, and finally empty space. Releasing on the wall is the third of those.

5 · 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 one creates two points: a wall-bound p2 where you started and a free p3 where you released, joined by the channel ch2.

You now have a chip: fluid enters at point, crosses the chamber, and leaves at p3.

6 · A wider inlet

Click point to select it. The inspector’s lower zone shows its placement, its layer span 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 to 100 µm where it meets the wall. Width is a value at each vertex, interpolated between them, and a channel end with no width of its own inherits from its point. Select p and give it 200 as well, and the run comes out one width.

That taper is worth leaving in place for a moment: it is the whole width model on screen. See Channels & points.

7 · 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.

Open the inspector’s Pins tab and tick world on that row. A world port is an opening to the outside — an inlet, an outlet, a well you punch — and the viewport marks it with a burst. Do the same for p3.

Everything else stays an interior connection, sealed inside the assembled chip.

8 · The chip in 3D

Press Tab. The slabs are drawn with their depth now: the chamber has a floor, the channels are trenches, and the cap sits over both.

Drag Explode in the Layers zone to open a gap between the two slabs — they are opaque, so that is how you look inside. Right-drag orbits, scroll zooms on the cursor, and F frames the whole design again.

Drag Explode back to 0 when you are done. It is a preference rather than part of the design, and it is remembered — leave a gap and the next launch opens with it.

9 · The design-rule check

Look at the Problems zone. 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.

Under the list, a dim line names the rules this process asks for that have no checker yet, so an empty report is never read as their passing. Nothing here ever blocks an edit or an export — the report states what it found. See Design rules.

If a row does appear, click it: the inspector opens on the thing that would fix it.

10 · A file on disk

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 — this file can be placed as a component library by another design without converting anything.

The • in the title bar clears when the save lands. It follows your edits rather than a flag, so undoing back to this point reads clean 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. Nothing in that frame opens, closes or resizes itself as you work — every panel and every zone inside one is always there, and only a drag moves a boundary. The one row that ever arrives on its own is the update banner, at the foot of this page.

The window: the menu bar over the left panel, the viewport with its toolbar and status bar, and the inspector

The full width of the window, above everything else: File, Design, Edit, View and Help. The document commands sit here rather than on the toolbar because they act on the whole design, not on what the next click does; View switches between the 2D and 3D views, and Help opens this guide and the About box. See Menus & files.

The left panel

A pinned strip over three zones, each scrolling its own content.

The strip is the quick settings — Grid, Snap, and the gear that opens the Settings window. It is pinned so no amount of content below can push it out of reach; the rest of the preferences live behind the gear (Settings).

Under it, in order: the browser zone, tabbed Components and Libraries, listing the components you can open and place (Components & Libraries); the Layers zone, which carries the stack picker, the base layer, the explode slider and one row per layer (Layers); and the Problems zone, the live design-rule report (Problems).

The viewport

The middle of the window, showing 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). Both the toolbar and the status bar span the viewport only — the two side panels keep their full height.

The inspector

The right-hand panel, and where you edit: a pinned header naming the open component, over a tabbed zone for the component and an always-present zone for the selection inside it. See Inspector.

The status bar

A single line under the viewport, read while you work.

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 is composed fresh each frame, so it tracks the tool you pick and the gesture you are in the middle of. 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 two readouts. ⚠ 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 one for the details. Neither is a button — the Problems zone is the list you click.

Boundaries and sizes

Both side panels resize from their inner edge, and the boundary between two zones 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.

Each panel has a minimum width, below which its rows would clip rather than reflow, and the viewport has one of its own. So dragging a panel wider stops where the viewport would fall below that floor, and shrinking the window past what all three need takes the space from the viewport first — the panels keep their rows intact. Zones behave the same way vertically: on a window too short for every zone’s minimum they all shrink together, and none is dropped.

What you drag to is kept. Both widths and every zone height are stored with your other preferences, so the next launch opens on the layout you left (Settings). A width a smaller window cannot honour is clamped for as long as that window is small, never overwritten — the layout you set on a wide screen is still there when you return to one.

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 ✕. They are not modal: the design stays editable underneath.

The export dialog, the unsaved-changes question, the file-error report and the About box are modal. Each dims the window behind it and takes every click until you answer it.

When the update check finds a newer release, a row appears under the menu bar naming the version, carrying a Download link and a ✕. It is the one part of the frame that arrives on its own, and a row rather than a dialog because a release is never urgent enough to interrupt an edit.

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.

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 authoring view: the grid is square to it and every shape reads at true position and size.

The 3D orbit view draws the slabs with their depth, so a channel is a trench and a chamber has a floor. It is where you check what the layers add up to.

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. Two pockets are the same color and abut exactly, so without it they read as one area; a hole needs no line, because it is already a visible gap. See Regions & compartments.

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

Right-drag orbits in 3D and pans in 2D — a top-down view has nothing to rotate. Shift+right-drag pans in 3D, and middle-drag pans in either view. Which of the two a right-press starts is decided at the press, so pressing Shift mid-drag does not switch it.

Scroll zooms, centered on the cursor: the point under the pointer stays under it, and each notch pulls the pivot onto what you are zooming into.

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 the way back after roaming with pan and zoom, and the recovery from an edge-on view.

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 terminal the open component exposes adds → name after that, and a world port adds a ».

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

Hover is scoped to the active tool: it shows what a press would take, so it never promises an action the press will not make. Under Add point, Add component and Draw region nothing lights — the crosshair is the affordance. 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, and between two at the same height the one on the active layer does. That is what makes a hole in an upper layer select what is under it rather than nothing.

Esc works down a ladder and takes the first rung 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 — which is the way back out of a region a click took you into.

Handles and markers

Shape says what a marker is: a circle is a terminal you can connect to, a diamond is a placed component’s pivot, a square is a vertex you can edit, and an outlined triangle flags a design-rule violation (Problems). Hovering or selecting grows a marker and lightens it rather than recoloring it, since its color already says which layer it belongs to.

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 — so the box doubles as a cue for what kind of thing you selected.

The left-drag

Left-drag moves what is under the pointer. The press selects first, so what moves is what you pressed on and never what was selected before; a press that does not travel stays a plain click. 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, so a constrained drag is exact from the first pixel. 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 glides along the wall it rides rather than leaving it.

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 — a right-drag is camera navigation, so the two never contend. 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 the delete for the compartment it belongs to (Delete compartment, Delete pocket or Delete hole)

Every one of these is an action the Inspector also offers, which is why the menu has no items of its own. A row the app would refuse stays visible and grayed with the reason in its tooltip — the same reason the inspector’s button gives.

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

The tool strip

Six icon buttons, five of them always present, exactly one 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, so a mistake costs one click rather than the tool. 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: the shape says whether the next press creates something or selects it.

While you have a component from Libraries open, the tools remain pickable and a press does nothing — another file’s component is read-only.

Select — S

The home tool: 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. 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.

Backspace retracts the last bend, and Esc abandons the gesture. Releasing back onto the start 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

Two forms again. Drag to sweep out an axis-aligned rectangle, holding Shift for a square. Or press and release without moving 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 — and one placed on an existing wall welds to it. The chip at the cursor names what the release will make, or why it will not; see Regions & compartments.

A refused release commits nothing. The rectangle is dropped; a polygon stays in flight with its vertices intact, so the fix is one Backspace rather than the whole ring again.

Insert vertex — I

Contextual: 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

Beside the tools in the same row, and present only for a tool that takes input. Select, Add point 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. Like the grid pitch it is a preference rather than part of the design (Settings).

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

The view switch

The 2D / 3D pair 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, and it sits on the toolbar rather than with the tools because it changes how you see the design, not what the next click does. See Viewport & navigation.

The Fab processes button

At the right end of the toolbar, opening the Fab processes window — the same window Design → Fab processes… opens. Its label is fixed rather than a readout: processes are a shared pool with nothing active about them, and which process a stack is built with is shown in the Stack window.

Components & Libraries

The browser is the top zone 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, since three is what the tab opens onto. Both tabs are always there.

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

One row per definition this design owns; a design with none reads (none).

A small dim star trails the root — the definition the file designates and the one that exports. It is a marker rather than a button. 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, so the header’s name field is the next thing under your cursor. 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.

Libraries

One collapsible group per library, Built-ins first and the rest by name. Built-ins ships with the app. Every other group is an .exw file sitting in the folder beside the design you opened, declaring a library identity of its own — the group header carries that library’s @version, and its full identity is on the tooltip. Two versions of one library are two groups, which is what tells apart components that share a name.

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

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, since picking from one is what creates the reference.

When the last file you opened had something to report about its libraries, the status bar’s ⚠ N library warnings readout carries it: a library file that changed since this design was last saved — re-save to clear it — or one beside the design that could not be read and that this design does not need.

Layers

The Layers zone is the middle of the left panel, and it is the stack as you view it: 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 zone holds the controls you reach for while drawing.

The first three controls are pinned above the rows, because their subject is the stack rather than any one layer.

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 design anchors at — its own layer 0 sits there. It is a design edit too, and the viewport always shows the design at that anchor, so what you see is what fabricates. The row is absent while the stack has no layers.

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. Slabs are drawn opaque, which is what makes explode the way to see a buried layer. Like the grid pitch it is a preference: outside the design, outside undo, and kept between sessions (Settings).

The layer rows

One row per layer of the active stack, an empty layer included — it 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, so the row reads as the geometry does.

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

The checkbox at the end of the row hides the layer. 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. What it does change is what the pointer can reach — you cannot select a shape on a hidden layer, and a region you draw will not weld to one, since you cannot join to what you cannot see. Visibility resets when you open another component (Components & Libraries); nothing else disturbs it.

Problems

The Problems zone is the bottom of the left panel — the design-rule report, recomputed on every committed edit and never a block on your work. Its title carries the running count, Problems · ✕ 3 · ⚠ 1, with each half dropped when it is zero. A clean report leaves the zone where it is and shows a dim no problems line rather than collapsing.

What each rule measures is Design rules; this page is the panel.

A row

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

One line per 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 the statement they are.

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, which under a per-layer override is not the process you were last looking at.

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 — it is a finding about a whole layer, such as more depths in it than the process forms in one go — and stays a readout.

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 rather than a subject, so it neither hovers nor selects anything; 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?. Nothing is capped and no count is hidden.

The unchecked-rule line

Under the list, a dim not checked yet: Min feature, Max aspect ratio names the rules that are enabled on a process forming your design but have no checker. It qualifies the report rather than belonging to it: those rules produce no rows, so without the line an empty report would read as their passing. Hovering it says as much.

It appears on a clean report too — that is where it matters most — and disappears when no governing deck enables an unchecked rule. Which rules those are is Design rules.

The counts

The title’s ✕ N · ⚠ M counts places, not rows: a row standing for 500 of them adds 500. It is the size of the problem, while the list under it stays the number of edits you would make.

The same pair sits at the right end of the status bar whenever the report is not clean, with the first few findings on its tooltip. Neither is a button — this zone is the list you click.

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 zone is the component; the lower zone 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 inspector with a channel selected: the Body tree above, and below it the channel’s ends and its fabrication rows

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 — the one the file designates and exports. It is disabled when the component already is the root, where the grayed star reads as a marker rather than a button.

The trash deletes the component. The deletion is refused if the component is the root, or if another component instantiates it; rather than hiding the button, the inspector disables it 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’s four facets are tabs, so the one you are working in gets the whole zone: 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 │ 🗑

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 │ 🗑

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 simply does not take effect.

Pins

name │ world │ source │ 🗑

The connection points the component exposes to whoever places it.

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 world checkbox marks the pin as a boundary port, and takes effect immediately. The source names the terminal behind the pin (← p1, ← mixer / out) and selects it when clicked; it is hidden when it would only repeat the pin name. Hovering anywhere on the row lights that 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 — the same way you create a child in the viewport rather than from a list.

Body

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 zone

The lower zone shows what is selected. It is always there — with nothing selected it says so rather than collapsing, because a zone that came and went would move the controls above it out from under your cursor.

Pinned at the top of the zone, the breadcrumb names the chain of scopes down to what you are editing — component, child, compartment, vertex. Each crumb is clickable, so it is also how you step back out. The trash beside it deletes the last scope in the chain, so read the final crumb before using it.

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 with 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 pins 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 point shows its placement, its span lo/hi and width, and whether it is exposed as a pin — with an Expose button when it is not. Where the point is a junction between exactly two channels, Dissolve into channel merges them back into one; it is disabled with a reason when the junction does not qualify.

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

A selected compartment

region · N vertices sits at the top of every compartment’s detail, and the fill control below it is the one that matters: 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 direction that would leave material inside material is disabled and the tooltip says which case applies.

The outermost compartment is the region child, so it carries the region’s own placement rows. A nested one carries a name field instead — leave it empty and it falls back to the derived label shown dimmed beside it — plus dx, dy and rot, which move the compartment within its parent. There is no layer row on a nested compartment: it cannot leave its region’s plane.

Fabrication

Void compartments, channels and points carry a fabrication group of override rows. 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 section 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. Both carry their own corner-radius rows, which override 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.

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 rather than blocking it — you can draw, and watch the Problems list 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 strip and the preset row stay pinned at the top and the rest scrolls, since the rule deck alone runs to sixteen rows.

The Fab processes window: the pool strip and name over the preset, compensation, corner radii, wall kinds and the rule deck

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 profiles 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 profile 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 profile — its wall kinds, corner radii, compensation, published deliverables and rule deck are all replaced, as one undo step. The process keeps its name, and the stacks pointing at it keep pointing at it.

It is a one-way load rather than a setting that reads back. Once a process exists it is just its authored data, so there is nothing for the control to display: you load a starting point and tune it from the rows below.

The rows below cover everything this window edits, with one exception: the deliverables a process publishes come from the profile it was loaded from and have no row of their own. What each process hands out is listed in the export dialog.

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, live. It is there because ticking the box and typing 0 is a different claim from leaving it unticked — parts land on size against nobody has checked — and the sentence is where the difference is visible.

Corner radii

Two fields in µm, inner (void) and outer (material): the radii this process forms at a corner of the void and at a corner of the material. 0 means sharp, which is an ordinary formed state rather than an unset one.

Wall kinds

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. The Problems list is the feedback: every feature asking for a kind the process cannot form gets a row.

The rule deck

☐ name │ threshold │ ✕

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 list uses.

Four rules are authorable but have no checker, and their rows say not checked yet — ticked or not — so that silence is never read as a pass. Tick one and the Problems panel repeats it under the report. Which four they are is Design rules.

Most thresholds are one number: µm for a length, × for a ratio, or a bare count. Three kinds 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 and Allowed depth increments open 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.

Every number here can be dragged as well as typed. A drag previews as you go and lands as one undo step when you release, and the Problems list 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.

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 zone, and like the Fab processes window it floats over the layout instead of blocking it.

It edits whichever stack the strip shows, which need not be the active one, so you can shape a production stack while a prototype target drives the viewport. Everything 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 window: the stack strip, the base layer, fab process and registration rows, and the two layer rows

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.

+ 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, and 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 design’s root 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: Common datum references every layer to one datum, while Sequential · RSS and Sequential · worst case reference each layer to the one below and differ in how the error along the stack adds up.

The layer rows

One row per layer, counting up from the substrate: 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 it is the last-layer rule alone that bites.

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

A layer’s detail

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 — which under a per-layer override is that layer’s own process, not the stack’s. A stored kind the process cannot form still names itself as the selection rather than being changed for you, and shows up in the Problems list instead.

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 (default)), so an unassigned layer still says which process forms it. Picking a pool process instead is what puts a laminated film over a molded body in one design — and it moves the wall list above it, 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.

Export

File → Export Fabrication Files… opens one dialog over the whole fabrication package. There is no per-format submenu, because a device’s files are registered against each other and described together — the package is the unit you hand a shop.

The center of the dialog is the list of files it would write. That list is rebuilt from the design as it stands, continuously while the dialog is open, and the Export button writes exactly the list you are reading.

Its settings — what is ticked, the version, the folder, the name — are per-export choices rather than preferences. They are seeded from the document each time the dialog opens — every deliverable that can actually be written ticked, the design’s own folder, the file’s name as the base — and go away when it closes.

The export dialog: one process block listing the two mask files it would write, over the DXF version, folder and base name

The target line

Stack: default, at the right under the heading: which stack these files fabricate. It is the active stack, so what export writes is what the viewport shows.

A process block

One block per process forming a layer of this stack, headed with its name and the layers it forms — default · layers 1–3. A stack whose layers all inherit one process has exactly one block.

Inside it is a checkbox per deliverable that process publishes, each with the files it would write listed underneath, grouped by layer, and the file format at the right of the row. The names follow one pattern: chip-layer2-mask50.dxf — the base name, the layer counted from 1, and what the file is. A mask set gives one file per distinct depth in a layer; cut contours give one per sheet.

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

Two absences are stated rather than hidden. A deliverable this build cannot write yet keeps its row, disabled and marked not exported yet — the process really does hand that artifact out. A process that publishes nothing gets its block anyway and says so, because a grayed row cannot tell you which case you are in.

The line closing each block is that process’s compensation: whether it is characterized, and at what scale. It is a statement, not an option — the on-screen twin of the sentence the files themselves carry. It sits inside the block because compensation belongs to the process, and one line over a stack where only some layers are corrected would be exactly the wrong claim.

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 'default'. The reasons are worth keeping apart: a process that publishes nothing, an artifact that cannot be written yet, and a deliverable you unticked are three different facts, and only the last is a decision. A featureless slab is not listed at all; a blank lid producing no file is the right answer rather than a gap.

When the folder holds leftovers from an earlier export of this package — a mask for a deliverable since unticked, a depth since changed — they are listed under a warning line, with one checkbox, Move into superseded/, governing the lot. It is ticked by default, which is safe for the two reasons the block provides: you see the list before it acts, and nothing is deleted — each file moves one folder down, so a misidentified one costs a drag back.

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 it, while R12 has no way to say so in the file, which makes that line the only statement and confirm with your shop worth doing.

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 in front of you.

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 zone lists — and does nothing else about it: shops accept files with open questions, and refusing to write what the viewport happily shows would be the tool overruling you. 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. Nothing pops up to be dismissed; the files are the result.

A failed write keeps the dialog open behind the file-error report, so you can point it at another folder and try again without setting the whole thing up a second time. A leftover the tidy-up could not move is reported in that same status note rather than as a failure — the package was written, and only the tidy-up fell short.

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

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 touches neither. Every item that has a shortcut prints it on its own row, so the menu is where you learn the keys. Shortcuts are inactive while you are typing in a text field.

File

New (Ctrl+N) replaces the open document with a fresh one: the default soft-lithography substrate — a patterned slab with a cap bonded over it — and one empty component named Chip, already the root. It is the smallest design that resolves, so you start on a blank canvas rather than on an error.

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 escape hatch. 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. It is always enabled: a stack whose process publishes nothing is explained inside the dialog rather than by a grayed row that cannot say why.

Design

Fab processes… and Stack… open the two fabrication editors — the same windows the toolbar’s process chip and the Layers zone’s edit button 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 on the stack 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, 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, and anything else — you are on the latest, or the server could not be reached — lands as a note on the status bar. It runs even with the startup check switched off, since asking outright overrides your own default. 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 land in. The version and the report are what a fault is triaged from — one that cannot be attributed to a release is hard to act on.

Every row here is always enabled. A failure that can say what went wrong is worth more than a gray row that cannot.

The window title

The title bar reads Chip — Experiware: the document’s name first, since that is the part the taskbar leaves visible. A leading • means there are unsaved changes.

The marker follows the edits rather than a flag — undo back to the point you last saved and the title reads clean again, redo away from it and the dot 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 lands. Dismiss the path picker, or hit a failed write, and the command is abandoned instead — the changes you asked to keep are 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, so a mistyped path costs nothing.

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 ever dies unexpectedly it writes a report before it goes: which build you were running, your platform, what failed and where. Reports land in crashes under %LOCALAPPDATA%\Experiware — the folder the About box states — and accumulate rather than overwriting each other, since two crashes in a row are often the tell.

The design you had open is not saved along with it. A crash costs you whatever the title bar’s • was covering.

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. They are yours rather than any one document’s: one set, carried across every design you open, and kept between sessions.

Two surfaces show them: the quick strip pinned 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. They are the two you reach for in the middle of a gesture, which is why they are the only settings with a permanent seat.

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

The Settings window

A floating window carrying every setting, including the ones set rarely. 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, so what you snap to is what you see. Every tenth line is drawn brighter. 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, and in 3D the grid is drawn on the active layer’s plane — so it moves with the layer you are working in.

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, so this is the strength of the contrast rather than a color of its own.

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 — so neither answer traps you mid-drag. Shift is already the axis lock, which is why the inverter is Ctrl.

Preferences that live elsewhere

Two more settings behave exactly like these but sit where they are used: the explode gap, on the Layers zone, and the default channel width, in the toolbar’s Draw channel options. Both are preferences in the same sense — outside the design, outside undo, kept between sessions.

The two panel widths and the zone 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; a drag writes once, when you release it.

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, so moving between versions never costs you a launch.

Components, parameters & pins

A design is a set of component definitions, one of which is the root — the definition the file designates and the one that exports. 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.

Definitions and placements

A 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. Beside them sit the args — one row per parameter — where you set what this placement passes in. 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. The app declines to author a placement that would close such a loop rather than letting you build one and meet it later.

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 is a plain real value; where one is a length it is micrometres, and where one is an angle it is radians. Int is a whole number, for counts such as the turns in a meander. Vec2 is a pair, read with .x and .y. Bool is 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, which is why the inspector shows it in parentheses and does not let you edit it.

The expression language

Expressions are small and pure. 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: the reason appears under the inspector header, and the viewport goes on showing the last version that built.

Pins

A pin is a connection point a component exposes to whoever places it, and pins are its whole public surface. A channel in the parent attaches to a pin; everything behind the pin stays private, and is regenerated freely when the definition changes.

You create a pin by exposing a terminal, not by adding a row to a list. Right-click a point in the body and choose Expose as pin, or use the Expose button in its detail block. Right-click a placed component’s pin — or use the Expose button beside it — and that pin is forwarded outward under the same name. Unexpose removes one.

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, and the tooltip lists what refers to it — the name is the contract other designs are written against.

World ports

The world checkbox marks a pin as a port open to the outside: an inlet, an outlet, a well you punch. Every other pin is an interior connection, sealed inside the assembled chip.

The built-in components leave world off. 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 root 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 — the connection is a channel, and there is always something between two things that are joined.

A pin named by two or more channel ends is a shared junction, so a fan-in is made by reusing one terminal rather than by merging several.

Built-in components

The Libraries tab lists components you did not author. The Built-ins group ships 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 listed under a group of its own. A library component is read-only: opening one shows its parameters, computed values and pins with no edit controls, and you set its arguments at each placement as for any other component.

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.

Nothing else connects. A channel always ends at a point, never at another channel and never at a region, so 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 — it shows in the viewport as a marker rather than 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 a layer span (span lo and span hi), the slabs it reaches through, with lo at or below hi. The span is authoring intent shown in the view; the exported geometry is built from the channels and regions around the point.

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 child in the body, 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 the contract, anchored to the points they connect. The interior vertices are geometry, and deleting one straightens the channel through it.

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. Ending in empty space creates a point there. Ending on the body of another channel splits that channel at the click and puts a new point between the two halves. Either way the whole gesture is one undo step: the channel you drew and everything it created come back together.

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. Nothing merges after the fact: two separate points never collapse into one, so a junction is always a terminal that was shared deliberately.

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 exactly as the bend it replaced, so the boundary between bend and junction is yours to move as a design takes shape.

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 of the edge, sliding along rather than letting the opening run off the end, and 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 arrives with inlet and outlet already placed on its wall and the wall still closed until you connect something.

Regions & compartments

A region is an area cut into one slab: a chamber, a reservoir, a well, a mixing cavity. Unlike a channel it has no route and no ends. It is a shape in the plan, and channels reach 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 exactly one, which the app presents as the region itself — no compartment row, no extra tier to navigate. Divide it and each piece gets a row of its own.

Every compartment has one of two fills, and the two words for them run through the whole app.

Void is carved: the fluid is there. A void compartment is a pocket, and it carries its own depth, wall profile and corner radii — which is what makes a shallow antechamber beside a deep well, or a step in a chamber’s floor.

Material is untouched slab: the fluid is not there. A material compartment is a hole, and it is how you author a post standing in a chamber, an island, or a wall between two halves of one shape.

Switching a compartment’s fill is the whole grammar. A pocket switched to material becomes a hole and the slab closes over it; a hole switched back becomes a pocket and is carved out. The direction that would leave material inside material is disabled, and the tooltip says which case applies.

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. The alternation repeats as deep as you need it.

A pocket set inside a pocket is never isolated from it: the two meet along the boundary and are one continuous void differing only in depth. Separating a void from the void around it takes a hole between them, which is the physically honest answer rather than a rule the app checks for.

A region needs at least three vertices in every ring, so deleting a vertex is refused at three.

The weld

Two shapes drawn independently never share a boundary exactly — their vertices land a hair apart, and a hair of material between two chambers is a wall you did not ask for. Welding is how a shared boundary is made exact: place a vertex on an existing wall and the shape you are drawing is joined to what you clicked, with no partition between them.

Four rules follow, and they are worth knowing before you meet them.

Click a wall twice and the run of wall between the two clicks comes along. A corridor off a chamber is four clicks, two of them on the wall.
A shape whose last wall click can reach the first one along the wall closes itself — there is nothing left to click.
Starting off the wall switches the self-closing off, which is what you want for a shape that meets one wall in two separate places.
When you do not want the wall between two clicks, put a vertex off the wall between them. The chip says place a vertex off the wall when it cannot route an edge any other way.

The chip at the cursor names what the release will make throughout — weld to, carve, split into, or the reason it is refused — so a refusal is never a surprise. The preview outlines the assembled ring, drawing borrowed vertices more faintly than the ones you placed, so what the tool brought along is visibly not yours.

Seams and movement

Welded compartments share their run of boundary exactly, and such a run is a seam rather than a wall. The app draws it as a hairline to say so: it is the one stretch of a compartment’s outline that fluid crosses.

Welding also merges the shapes into one movable unit. Drag a welded compartment and its neighbours come with it — there is no piece left behind. A shape set inside another, 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. That is refused where it would destroy something you wrote — 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 where the region is divided, and the whole shape where it is not. It is refused while a channel lands on that compartment’s wall, since the alternative is silently moving a landing onto a wall you never chose.

Removing a piece is also how a wall is authored at the top level of a region, where a hole cannot go: carve a chamber into three and every piece is a pocket, so deleting the middle one lets the slab close over it and leaves the two ends separated. One tier down — inside a pocket — the wall can instead be a hole with a row of its own.

Compartment names

A compartment with no name of its own reads 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. There is no layer row on a nested compartment: everything in one region is cut into one slab.

Regions in the network

A region is not a connection. Channels reach it only through wall-bound points, and a region with no wall-bound points on it is a passive cavity — a shape in the slab that nothing flows into.

Layers, stacks & processes

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

The stack

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

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

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

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

Faces, depth and the roof

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

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

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

Several stacks, one active

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

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

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

Processes

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

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

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

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

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

What a process does not change

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

Fabrication overrides

Most of what decides a feature’s shape does not sit on the feature. A channel’s depth comes from the layer it is drawn on; a corner’s radius comes from the process forming that layer. An override is where you say otherwise for one child, and one grammar covers every such row.

The grammar

Every override row carries a checkbox.

Unticked, the value is inherited, and the effective value is shown dimmed beside the name of where it came from. Ticked, the value is this child’s own.

Ticking seeds the override from whatever the row is displaying, so ticking alone never moves any geometry — you tick, then edit. Unticking clears the override and returns the row to tracking what it inherits, which is why an inherited value follows a later change to the layer or the process instead of going stale the way a copy would.

A child sitting off the stack has no layer to inherit from. Its unset rows read — and cannot be ticked; overrides already on it stay editable and removable.

Which children carry them

Void compartments, channels and points carry a fabrication group. 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 appears only at the child itself, 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 the parameter row appears only when the profile has one to set. Leaving the parameter unset means the process’s forming default, live — so it follows a process edit rather than 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 list reports it.

Corner radii

A drawn corner is infinitely sharp and no instrument is, 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 — so you never pick a class, you set the pair.

Corner radii inherit from the process, not from the layer, because a layer already names the process that forms it. Under that base sit two authored tiers:

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

The two arms are independent. Override the inner radius 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, and its row names the class that corner takes there. Drag the vertex from convex to reflex and the value follows it into the other class. A channel station and a point each induce corners of both classes, so each authors the pair.

A channel end carries no corner rows 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.

Design rules

Experiware checks your design against the process forming each layer and reports what it finds in the Problems panel. The report is live — recomputed on every committed edit — and it never blocks you. A design with errors still builds, still displays and still exports; the export dialog states how many are outstanding rather than refusing to run.

Rules are data

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

The consequence worth taking on board is that 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. That is deliberate: a rigid molded part has no roof problem to state, and a placeholder threshold would be the opposite lie.

Which process governs

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

What is checked

Min wall — a wall or gap between features thinner than the process holds, 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.
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 layer that cannot be built from the sheet thicknesses available.
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 works. 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, and four of them you can set a threshold for without anything measuring against it:

Min feature — a void narrower than the process resolves.
Max aspect ratio — a feature deeper than its own width by more than the process holds.
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.

Each wears a dim not checked yet note in the deck table, ticked or not. Where one of them is ticked on a process forming your design, the Problems panel repeats it under the report — so an empty report is never read as those four passing.

The first two are the ones to watch, because every process preset ships them enabled. A preset’s Min feature threshold is the real number for that process and worth reading, but the report says nothing about your narrowest features, in either direction. Measure those yourself.

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. Its absence rule runs the other way round: an empty wall list allows nothing. It is always an error — a fab that cannot form a shape cannot form it at any threshold — and a kind left stale after a stack switch is reported rather than quietly changed.

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 declined rather than measured. A hole that escaped its region would otherwise report a confident wall thickness that means nothing, so you get one row explaining the defect instead of two rows disagreeing about it.

Rows track edits, not occurrences

A pillar array at too tight a pitch is thousands of offending pairs and one edit. Every part of the report is built around that. A row says how many places it stands for rather than listing them, the viewport draws one marker per row, and hovering a row reveals its other occurrences.

Past ten rows the list folds into one group per rule kind, each header carrying its glyph, label and total (✕ Min wall · 37) and starting collapsed. At that scale the question is whether you are looking at one systemic thing or thirty separate ones, and the header answers it. Where a single rule accounts for nearly the whole of a large report, its header adds a question — 1240 of 1250 places — check the process? — because that concentration is usually one wrong process or a units slip rather than that many independent mistakes.

Nothing is capped and no count is hidden. Hovering a row lights its subject in the viewport; clicking one selects it, so the parameter that would fix it is one glance away. The zone title and the status bar both carry the running ✕ N · ⚠ M count.

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.

Key	Tool
`S`	Select
`D`	Draw channel
`P`	Add point
`C`	Add component
`R`	Draw region (where you press decides what you draw — see below)
`I`	Insert vertex (only while a channel or region is selected)

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 Regions & compartments for the welding rules.

View

Key	Action
`Tab`	Toggle 2D top-down ⇄ 3D orbit view
`F`	Frame the camera on the selection (or the whole design)
`Esc`	Close the context menu / abort the current action / return to Select; otherwise step the selection out one tier

Editing

Key	Action
`Enter`	Finish the channel being drawn / close the region polygon
`Delete` / `Backspace`	While drawing: retract the last bend. Otherwise: delete the selected vertex
`Ctrl+Z`	Undo
`Ctrl+Y` / `Ctrl+Shift+Z`	Redo
`Shift` (during a drag)	Lock movement to one axis; constrain a dragged region to a square
`Ctrl` (during a drag)	Invert grid snapping

Files

Key	Action
`Ctrl+N`	New design
`Ctrl+O`	Open…
`Ctrl+S`	Save
`Ctrl+Shift+S`	Save As…
`F1`	Open the user guide

Mouse

Input	Action
Left click	Select (or apply the active tool)
Left drag	Move the selection / draw with the active tool
Right drag	3D: orbit · 2D: pan
Middle drag, `Shift`+right drag	Pan
Scroll wheel	Zoom, centered on the cursor
Right click	Context menu for the item under the cursor

Keyboard shortcuts

Experiware Guide