slicerman

Turn a 3D mesh into flat parts you can cut on a laser — parts that hold themselves together with no glue and no screws — by sketching the cuts yourself, on a phone, with the object in front of you.

Drop in a file. Set how big you want it. Turn the object, place a cutting plane where you are looking, press lås. Repeat. Download the sheets.

slicer.iverfinne.no — runs in the browser, nothing to install, no account, no licence key. Your mesh never leaves the machine it was dropped on.

The interface is in Norwegian (nynorsk). The code and this README are not.

What it does

Every part is a plane cut through the body, with slots where it crosses other planes. Any two planes that cross in material lock together: one gets its slot from one end of the shared line, the other from the other end, and the part that comes later in the list slides onto the ones that are already there. A grid of ribs is one thing you can build this way; a set of planes at angles no grid could describe is another. The tool does not care which.

It opens on 3 mm MDF on a 600 × 400 mm bed — the common "6040" CO2 laser — with a cube and no cuts: the body sits there as a shell and the first thing you do is cut it. Want a grid, switch on rutenett and set the columns and rows with two fingers. Change the thickness to the sheet in your hand and the bed to your machine; the project keeps both.

It is a laser tool. No cutter diameter and no dogbones, because a beam has no radius.

Use it

1. Pick a body. The pill at the top opens the body: one line per family of built-in shape (kube, stolform, sau, dyr) and your own files — .glb, .gltf, .stl, .obj, .ply, up to 220 MB, or a .zip saved by LAGRE. A shape is added beside what is already there, overlapping it, so the body is all of them together — a sheep next to a cube, a stool into its side; the pill then says kube +2. tøm goes back to the source alone, and undo takes a piece off again. A file starts over, and a new body clears the planes: they were an answer about the body you had.

   With a piece selected, a choice swaps it instead of adding one. Pick a piece in the body tool and the same menu changes that piece: another family swaps its shape and keeps its place, size and rotation, and the same family again steps to the next version of it. That is how you page through the ten stools with the body in front of you instead of choosing from a list that covers it. A file you fetch goes into the selected piece too, and the source, the other pieces and the planes stay where they are.

2. Compose it. The cube button under your thumb opens the body tool: every piece stands as a box you can press. Two fingers on the selected one move it (horizontal slides it along the floor, vertical lifts it), twist it about the upright, and pinch it larger — and two buttons appear to duplicate or remove it. That is how a seat gets on top of legs. The sketch is hidden while the tool is open: one tool at a time.

3. Set the size. Drag the number, or take it from the sheet.

4. Sketch a plane. One finger turns the object. The sketch plane is a line across the screen — a knife seen edge-on — with a grab handle in the middle and a rotation handle at the end: drag the one to move the cut across the object, the other to tilt it. Two fingers on the object aim the cut: drag moves it and twist tilts it — both at once, each with its own dead zone, so a hand that wants to nudge and tilt gets both. The camera is not in it at all: see two fingers never move the camera, below. Zoom is the magnifier under the view cube. Neither gesture touches the body — the size is a number you drag and the turn is the body tool; a body that grows when you want a closer look is a body doing something you did not ask for. Three fingers move the light. The plane swings with the view and nothing is built from it — and a double-tap does nothing, because a reframe you did not ask for throws away the angle you were finding.

5. Press skjer — the big button under your right thumb. The sketch shows the slice it would make while you aim: the section through the body, and marks where it would lock into planes you already cut, with the joint count on its label. Cut, and the section becomes a part: a name, a profile, slots against every plane it crosses, a place in the assembly and a row in the list. Turn the object and cut again. The cut planes stay where you put them while the view turns.

6. Or set a grid. Switch on rutenett (or press R) and two fingers set the two numbers: sideways is columns, up and down is rows. It replaces the grid and leaves everything you cut by hand, and the whole drag is one step in undo.

7. Read the rules. They say what can't be cut or assembled, and why, and most broken rules carry the button that fixes it.

8. Export ARK and open it in LightBurn.

Every change is undoable and redoable: the two arrows at the top, or Z and ⇧Z.

Two surfaces

The iPhone 16e, saved to the home screen, is the target device — the only one: one thumb, a 390-point screen, the object visible while you work. The page itself never zooms, scrolls or lets you select anything; every gesture belongs to the object. A slim bar at the top carries the body you are working on (tap it for a primitive, another file or the project), the four views, undo and share. A sheet at the bottom has three heights: one line (the live count, the grid tool, export), the middle (size and the plane list), everything (material and thickness, the sliders, the table with the rules and their fixes, the tools). The tools float above it in a column under the right thumb, with the cut button at the bottom; the column is a band from the top line down to the sheet, so a long stack stops at the line instead of disappearing behind it. The two layout tools — the grid and the vortex — sit at the top of it, above everything that belongs to a single plane, because they are the same kind of thing: both write the whole plane list, and both are set with two fingers. A tool you can only reach from a keyboard does not exist on the phone.

The column carries what the view can show. A tool is a question and an answer: you press, and something changes in front of you. If the answer is drawn in a picture that is not up, the button is only the question — and a question with no answer is worse than no button. So in the room (flate and lag), where the body, the planes and the sketch are drawn, all of them stand. On the plate surface only the two a button can do on its own and the sheet shows at once — duplicate and delete the selected part's plane. The hole, the outline, the bend and fordel all draw themselves on the canvas, which lies hidden under the sheets there; the grid, the vortex, the body tool and skjer are all set with fingers on the object, and the object is not there. In the montage the column carries the step, and nothing else: it changes nothing at all.

The band starts below the view cube, not below the top line. Both columns sit in the same edge of the screen — the cube with the padlock, the reframe and the magnifier at the top, the tools at the bottom — and a stack long enough reaches up into it: measured, eleven buttons, and a press meant for the reframe button went to the grid tool. The cube's lower edge is measured rather than written down twice. Eleven, because opening the body tool left a plane selected as well as a piece, so both sets of tools stood there at once; the body tool now lets the plane go, the way the grid, the vortex and the montage do, and the plane's tools stand down while it is open. And the buttons do not shrink: with the sheet fully open the band is shorter than the stack, and flex answered that by squeezing them to 16 pixels with touch targets lying on top of one another. A button has a size because a thumb has one. pnpm panel boyen checks all four things — on screen, clear of the cube, the reframe button taking its own press, and nothing under 44 px.

The view cube, top right, turns with the camera and is how you aim it: press a face for that side, an edge for the 45° view between two, a corner for the isometric between three, and the camera swings there. It is drei's GizmoViewcube — geometry in the canvas, hit by the same raycast as everything else in the scene — not a hand-built one, and it is 45 px. Under it is the padlock that holds the view still (below), then the reframe button, which fits the object back into the screen, and under that the magnifier: press and drag it up to go in, down to go out. Out is 3.4 times the framed distance — the ceiling was one and a quarter, which is not enough to see a body with many planes in it. The body turns the whole way round, underside included.

Dark is black. There is no toggle: the page takes the system's setting and inverts the four colours it is built from — paper becomes black, ink becomes white. No dark greys; a grey surface is a third layer that does not exist in the light version either. The 3D view follows the same two tokens, so the canvas is black too. What does not follow is the output: an SVG, a DXF and a PNG are black on white paper whatever the screen is set to, because they are documents and not interface.

A value row takes the wheel. Where there is a mouse, one notch is one step and shift is ten — the same two steps the arrow keys give — and the panel under the pointer holds still while you turn it. Drag the row sideways, type the number after a double-click, or turn the wheel: same row, three hands.

Over 1180 px with a mouse, no sheet — the same controls as one column on the right, the top bar above the canvas, and the camera frames the object into whatever rectangle is left over. The bench is where precision lives, because that is where the keyboard is. Every number in the column can be typed: double-click it (or press enter with the row focused), type, enter sets it and escape leaves it; arrows step it, shift-arrows step ten. A selected plane moves one millimetre along its normal per arrow press, ten with shift, and its row reads where it stands in millimetres from the centre of the body, live. T draws a face, D duplicates the selected plane, H cuts a hole in it, O freezes its profile into points (twice quickly for the box), the arrows move a held outline point one millimetre and ten with shift, B switches it between corner and arc, ⌫ removes it, tab and shift-tab walk the plane list, F reframes, and the right mouse button (or the wheel pressed) pans the view — the reframe button puts it back. Every tool has a letter: R the grid, V the whirl, K the body, M the montage view, and B leafs the selected piece to the next version of its family (or, with an outline point held, switches that point between corner and arc). The grid and the whirl take the mouse too: they were two fingers and nothing else, so on a bench the switch went on and nothing happened. With either open the left button is theirs — sideways sets columns (or ribs), up and down sets rows (or how far out) — and the orbit stands aside until you let go. On the sheet, arrows nudge the selected part a millimetre, and shift-arrows ten. A phone gets none of this: one thumb has no arrows. Numeric rows do accept a double-tap on the phone: the temporary field uses 16 px text and a decimal keyboard. Under materiale, the third page (passform) sets the measured thickness and clearance exactly; the thickness shortcuts now include 9, 12, 15, 18 and 24 mm.

With a part selected (tap it in the object), the handles and the two-finger drag edit that plane instead of the sketch: the centre handle moves it in its own plane, the normal handle pushes it along its normal, the rotation handle re-angles it, and two fingers still push it along the normal. Tap empty space to deselect; the row's slett removes the plane.

Planes made in one action are a group. A grid is two groups (across and along), a whirl is one, a mirrored cut is one, and duplicating a group makes another. The group has a row in the list above its planes, and that row is all you see of it until you ask for more — a grid is thirty planes and the list is most of what a phone shows. Tap it and the whole group is selected and unfolded; tap it again and it is let go and folded back. Whichever plane your hand holds stays in the list either way: the list always shows what you have hold of. Whatever you do to that plane the group does too: the handles, the two-finger drag, the arrow keys, slett, dubler. fordel, under your thumb while a group is selected, decides how: off, the whole row moves and turns as one; on, the far end stays, the plane you hold takes all of it and the ones between take their share, so turning the last rib fans the row along a curve and pushing it re-spaces the row evenly. Select another group and the first stays open, and a plane you tap on its own lets the group go. The group is a tag on each plane in the plane string (g:1), never a thing of its own: each plane is still its own point and normal, and a plane you move alone stays in its group.

A heading folds what is under it. The same tap wherever a list has groups: the section headings under alle kontrollane — form, nett, delar and the rest — fold their sliders away, and a plane that gave several parts folds its rows behind its heading in the cut list. It is a way to see, not a setting: nothing about it is written to the project, and a reload has everything open again.

A plane can carry a layer. Under a selected plane the list shows LightBurn's own palette, C02 to C29, and a ring for none. Pick one and every cut of that plane, outline and holes, is written in exactly that colour, so LightBurn puts it on that layer where you give it its own speed, cut it last, or switch it off. Black and blue are not on offer: they are the engrave and the cut, and the order lives in them. With a group selected the pick tags the whole group. The sheet draws a tagged part in its colour, the list shows a dot, and the DXF gets a layer named after the LightBurn colour with the exact value as true colour beside its nearest ACI. Untagged files are unchanged: two colours, as before. The same layer on a piece of the body also binds the plane to that piece — see The body.

The contour view IS the sheet. It was a ribbon of profiles laid out side by side in the canvas — the same drawing the sheets already showed, only with no way to touch it. Now the third view is the sheet: the parts where the laser will cut them, one finger to drag a part, hold for its menu (pin, turn, next sheet), two fingers to drag and turn a selected one, one finger on bare board to pan, double-tap for the whole sheet. Tapping a part selects the plane it was cut from, and the thumb column then offers the two things a button can do on its own here: another plane like it, or that plane gone — both of which the sheet redraws in front of you. The rest of the profile tools stay in the object view, where their handles are drawn. There was a pen and an eraser here for a while — one finger inside the frame drew a freehand mark into the plate — and they are gone; marks on a plane are placed in the object view, where you can see what you are marking.

The 3D room stays mounted behind it, hidden rather than torn down, so stepping out and back does not reset the camera. "plater" is no longer a drawer tool — it is the same surface, and showing it twice was the whole complaint.

Slot ends are handles. Select a part and every joint on it gets a dot at the closed end of its slot, on a hairline track showing how far it can travel. Drag one and that joint alone gets deeper — and the other half of the joint gets shallower by exactly as much, because both slots read one number off one line. jamt in the sheet's toolbar hands every joint back to the slider. The same dots are in the room. Select a plane and every joint on it gets one, on the closed end of its slot, with the band it can travel drawn behind it — because the body is what you are looking at when you decide which rib should carry. The finger is read against the joint's line in space, not against a surface, so you can drag from any angle and the camera holds still while you do. With a plane selected, the two buttons under your thumb are skjer hòl and dubler planet. The second used to add a rectangle of material to the profile; it duplicates the selected plane now — same normal, same strokes, shifted one notch along the normal so the copy is not inside what you copied, and the copy is what stays selected.

Nothing sits on the object but the handles. The label that read the joint count and the millimetre off the sketch is gone from the screen: the sheet already says both, and it covered exactly what you were aiming at. The handles are 22-pixel marks at half ink, full ink while you hold one; their touch targets are still 48.

Two fingers never move the camera. Not at the end of a gesture, not for one frame in the middle of it, and not even when the gesture is a pure pinch. Two fingers belong to the object.

The pinch used to zoom the view, and it had to go. The three channels share one motion, and they do not declare themselves at the same speed: the drag has to travel six pixels, while the pinch has to change the gap between the fingers by four per cent — and on a hand spanning 160 pixels that is six and a half pixels split between two fingers, three each. Nobody puts two fingers on glass and drags them without them sliding three pixels apart first. So the pinch won the opening of every single drag: the camera dollied a notch, the drag then took the gesture, and the camera was put back. The putting back was the thing you could see — a jump out and a jump in, every time two fingers touched anything. The tests never caught it, because they measured where the camera ended, and it ended exactly where it started.

That can be softened — bigger dead zones, a window before the camera may have the gesture — but it cannot be removed, because no dead zone can read what the hand meant. So the camera is out of the contest entirely. Zoom is not gone; it has its own control and no arbitration: the magnifier under the view cube, press and drag like the bend, and the wheel on a bench. One way in per thing.

The body tool is unchanged, and that is not an exception to the rule: there the pinch is the subject. The piece grows while you move and turn it, because that is three things on the same piece, not two things fighting over what you were pointing at.

The tests read the camera distance after every step while the fingers are still down. Measured on the code before this: 0.689 units of swing mid-drag, with both end-state tests reading 14.450 → 14.450. Now a drag, a pinch, and a pinch followed by a drag all read 14.450 → 14.450, and the worst mid-gesture deviation is 0.0000.

Two fingers, one cut. Hold the sketch handle with your thumb and tap skjer with a finger — the plane is cut where you are holding it, and the handle never leaves your thumb. Browsers only synthesise a click from the first finger on the screen, so the second tap never reached the button; the thumb column reads the pointer itself when it is not the primary one. Let go outside the button you pressed and nothing happens, which is how a tap is cancelled.

The view is a decision, not a consequence. The frame used to be worked out from the geometry: the scale was FRAME / longest side and the centre was the centre of the box, so every change moved and rescaled the whole picture. Drag a piece out and everything else shrank while your finger was still on it, and you were aiming at a target that slid away. The camera did the same thing whenever the radius moved 10 %. Now the scale and the centre stay where they were set, and the geometry moves inside that frame. It is set again only when somebody asks: the reframe button, a face of the view cube, or a new body — opening a file is not editing.

The box itself is still live. A plane's origin is a fraction of it, and a plane at 0.5 has to sit in the middle of the body as it is now, not as it was. Only the view holds still.

And it can be locked. The padlock above the reframe button takes that decision all the way: with it closed, nothing angles the object — not one finger on the canvas, not an edge or corner of the view cube, not the reframe button, which then fits the object back into the screen from where you are already standing instead of swinging home. The six faces of the cube still work: looking straight down an axis is a working plane, not an angle, and it is how you get to the next side to draw on. Zoom is still yours: going closer is not a new angle, it is the same view from nearer. Aim the object once and the rest of the session is aiming at it, not at it and the camera both.

A side is a side, not a perspective. Press a face of the view cube and the camera swings there — and as it lands, the perspective flattens out. Two ribs the same length come out the same length on screen, a plate facing you has no splayed edges, and you can read a shape off the screen instead of guessing at it. Turn away from the axis and the perspective comes back on its own; the rule is the geometry, not the button, so a finger that lands you square on gets the same view a cube face does, and nothing else in the app needs to know this exists.

It is not a second camera. An orthographic camera is a different projection matrix, and everything that works in screen points — the sketch, the handles, the outline, pxPer — would have needed two versions of itself, one of which would be wrong the first time somebody forgot it. Instead the field of view is narrowed: 30° down to 2°, while the camera walks the same factor further back, so d · tan(fov/2) — which is what decides how big a thing lands on the screen — holds still and the image does not move a pixel while it straightens out. At 2° the rays are parallel to 1.4 %, under a pixel across an object on this screen. The threshold is 2° off an axis, with 3.2° to leave again so a shaking finger crosses once instead of flickering; the floor under that number is the orbit's own pole clamp (1.15°, so the top and bottom faces never sit exactly on the axis) plus what the cube's swing leaves behind.

Two things follow the camera out there. The ceiling on how far back you may go is a number in perspective, so it scales with the field of view — you get the same 3.4 times the framed distance either way. And the near and far clipping planes stop being 0.1 and 1000: at 222 units out, a near plane at 0.1 leaves 0.03 units of depth resolution, half a rib, and two ribs side by side start flickering about which is in front. Laid around the distance instead, the same step is 2.5e-6. The fog already worked this way, for the same reason.

A finger that lands after a turn does not inherit the spin. OrbitControls damps: let go mid-turn and it keeps swinging for a few frames, and controls.enabled = false only stops it listening — the leftover sphericalDelta is still spent, a slice per frame. So the ordinary phone motion, one finger turning the view and the second coming down to cut, handed the second finger a camera that was still moving, and the position we restored was overwritten in the next frame. Now taking the camera spends the remainder in one step (one update() with damping off) instead of waiting for it to die out.

Each side of a piece has a dot. In the body tool, a selected piece shows six small dots, one on the middle of each face of its box. Drag one and that axis alone stretches — a cube becomes a plate, a cylinder an oval. The pinch still scales all three at once and keeps the proportions; the dot is for when you want a stool and not an inflated cube.

A dot owns the finger, and the camera with it. A dot is DOM over the canvas, so its finger never reaches the orbit — but the other hand's does. A hand holding the phone rests against the glass while the thumb drags, and that resting finger was the first one the canvas saw: the orbit read it as a single finger and swung the body right round while you were stretching one side of a piece. The dots now take the camera the way the sketch handles, the slot dots and the outline points already did, and the canvas takes no pointer at all while one is held. The listener had to stop depending on the canvas size first: that value is rewritten more often than a canvas changes shape, and every rewrite ran the listener's cleanup — which is the line that hands the orbit back. The gesture announces itself as the finger goes down, the studio redraws, and the cleanup switched the orbit on again mid-drag. A listener that must survive a drag cannot hang on anything that changes during one. pnpm panel telefon puts the fingers down one after the other, because that order is the whole bug: a two-finger touch dispatched as one event never had it.

The size of a piece used to be one number. It is three now, one per axis, and three equal ones are written as the single number they used to be — so a project from last year opens the same object, and a project with a plain cube in it does not grow for something nobody touched. The dots are DOM, like the sketch handles and for the same reason: a 44-pixel target you can hit with a thumb and a name a screen reader can say. The scene only works out where they go, every frame.

A plane does not have to be flat. Select one and drag the bend button under your thumb: the cutting surface becomes a cylinder, straight along v and curved along u. Double-tap the button and the plane is straight again — a scrubber has no way back to nought except dragging yourself there and missing by a hundredth, so the button is its own way out, the way form is. A cylinder is developable — it unrolls to a flat sheet without stretching — so the part is still cut flat and you bend it on assembly. That is why it is a cylinder and not a sphere.

The number stored is curvature times size, not a radius in millimetres, so a bend follows the body when you scale it. The radius in millimetres is what the material has an opinion about: bending strains the outer fibre by t/2R, and past what the material takes, the sheet splits — in the workshop, not on the screen. Plywood takes 100×t, MDF 200×t, acrylic 230×t cold, cardboard 10×t: 6 mm plywood bends to 600 mm as a solid sheet, 3 mm to 300.

Tighter than that, the sheet is scored. Rows of cuts across the bend, parallel to the cylinder axis, one plate thickness apart, staggered so the ligaments between them never line up — the plate stops bending as a plate and starts bending as a hinge. The cuts are open lines, not rings: the opening is the kerf itself, which is the one place in the tool where kerf is the shape rather than an error to compensate away. They are written into the cut file with the inner cuts, before the outline, so they are made while the part is still held by the sheet.

Around every joint the pattern stops. A band runs the full length of each slot line, three thicknesses to either side, and no cut crosses it — the material that carries a joint is not perforated. That band is also what keeps the joint arithmetic true: joints are measured along their slot line, and a score cut across that line would hand the joint a shoulder that is not there.

Or don't score at all — slat it. A slat is a bent plane carrying a narrow outline: u is the bend, v is the cylinder axis, and each slat takes its own strip of v. Ribs with their normal along u lie along the axis, so they meet every slat in a generator line — the clean case. Six slats and three ribs on the same curve as a scored skin: 12.7 m of cutting against 43.5 m. For anything you sit on, that is usually the better answer than turning a sheet into one large hinge.

A bent part is bent into place, not pushed into place, and that holds from both sides: a joint against a bent partner constrains no insertion direction, whether the bent part is the one arriving or the one already there. That is what makes the useful construction work — a scored skin over a rigid frame. Build the waffle flat, wrap the skin around it. Each floor carries arcs against the skin and straight slots against the ribs; only the straight ones are the way in.

So the rule is no longer hard, and it no longer only offers to straighten: it says what the pattern costs. It goes red only when the pattern cannot be laid at all — when the tool is so coarse that the kerf eats the row spacing. What the tool does not compute is whether the ligaments survive the twist: that is torsion in a material that is not the same in two directions, and it is not read off the geometry. Cut a test strip.

Inside, a bent plane does not slice the body — it unrolls the space. The cylinder becomes a plane again in the unrolled space, the slice is the same z-slice as any other, and the profile that comes out is already the flat pattern, because unrolling turns arc length into length. Straight triangle edges become curves on the way, so edges longer than √(8·R·tol) are split first; without that a cube would come out as a box with straight sides claiming to be bent.

A bent plane carries joints against flat ribs along its axis, and against floors across it. The slot machinery is built on two surfaces meeting in one line with one curvature. Two planes always meet in a line. A cylinder and a plane do it in two clean cases, and they are each other's opposite extreme:

• along the axis — the meeting is a generator line, straight in space and straight unrolled, because u is arc length and the line has constant u. That is the curved shell with flat ribs across it.
• perpendicular to the axis — a floor, a deck, a lid. The plane cuts the cylinder in a circle of exactly the cylinder radius. In the unrolled pattern that circle is a straight line at constant distance along the axis, so the bent part's slot is an ordinary slot; in the floor's own frame it is an arc, and the floor's slot follows it. That is the curved shell with floors, and it is the other half of what people actually build.

So a slot line has a curvature now, and it is the only place in the house where one does. The two sides of a joint still share one number: mouth, bottom and exit are arc length, and both maps into the two frames preserve length — unrolling a cylinder is an isometry — so a deeper slot on one side is still a shallower one on the other, with nobody converting anything. The probe reads the radius back off the cut slot: 1000.0 mm against a cylinder of 1000.0 mm, worst error 1.4e-12 mm, and the same set bent and flat counts the same 32 joints — bending takes no joint away and invents none.

And a bent part is not pushed into place, it is bent into place. A flat part can only go one way, which is why joints along non-parallel lines are a break for it. A cylinder has only two kinds of joint — generators along the axis, arcs across it — and rolling the part down takes both: the generator stands still while the surface curves, the arc engages like a zip. So a bent part is exempt from that rule, and montering.txt says bent into place where it would otherwise say a direction.

What is left open is the slanted plane — neither along the axis nor across it, where the conic neither straightens nor closes into a circle — and two bent surfaces, which meet in a space curve. Those meetings are counted and named, a bent rib that finds no joint at all comes out as a loose plate, and a hard rule says so — it counts ribs without slots, not bent planes, because after this step those are no longer the same thing.

The chrome dozes. Two seconds without a finger and everything that is not the object fades away — the top line, the thumb column, the sheet, the sketch handles, the view cube, the cut preview — and any movement brings it back in ninety milliseconds. Only at rest: with a plane or a stroke selected, a drawer open, the sheet up, a tool running, the sheet surface showing or the engine still working, you are in the middle of something and what is in front of you stays. While it is gone the interface takes no touches, which is why it only dozes at rest — the first tap then has nothing to hit on the object either, so it wakes and does nothing else.

Words, not pills. The views and the three mirror axes were rings with a filled pill under whichever one applied. The ring said nothing the word did not, and the filled shapes sat in the middle of the picture. They are words now, in the same ink the icons use: full ink when it applies, dimmed when it does not. The mirror axes moved to sit directly above skjer, which is what they change — and they stand in the room only, since a mirrored cut is something you see on the object. Four words and a long file name are wider than 390 points, so the name is the one thing in that bar that gives: it truncates, because a shortened file name still means something and half a view word does not.

The shell has a switch. In the parts view the body you started from is drawn transparent around the ribs, so you can see how much of the shape they catch. It is also what stands between you and the slots. The button under the reframe icon takes it away and puts it back; the project keeps it, so you come back to the view you left. It changes no geometry and is not in the undo list.

Keys: L cut, O freeze the profile, R grid tool, V vortex, M montage, B corner or arc on a held point (else leaf the selected piece), ⌫ remove what is held — an outline point, else a stroke, else the plane, Z undo, ⇧Z redo, 1 2 3 4 views, Esc close. The tool keys are the room's, like the buttons: on the plate and in the montage they do nothing, because there is nothing there to see them do it.

The browser keeps projects, and you press nothing to keep them. Every change is written to the open project in IndexedDB as it happens — settings, view, shell — and once more as the app goes to the background, because iOS kills a home-screen app without asking. Opening the app opens the project you left. A project has a name and sits in a list in the drawer: open one, start a new one, duplicate, rename, delete (see Projects). The unlocked sketch is disposable and is not kept; it costs one gesture to make again.

The link carries nothing any more. It used to carry every setting, written into the address bar by the app itself, beside a session that held the meshes — two truths about one afternoon, and a reload always believed the link: the file you had dragged in sat in the database and was never asked for, and you came back to your ribs on a cube. An old #p= link now just opens the app; the hash is wiped, not read. LAGRE is the exchange format — one project file with the settings and every mesh — and the share button shares exactly that file, through the share sheet on the phone and as a download where there is none. Opening a project file makes it a new project, named after the file.

Meshes are stored once, per source, not per project. Each lives under the name its bytes give it — the same name the scene string and the project archive use — so two projects built on one scan share one copy, and settings pasted from someone else cannot pull a mesh out of your database: they have to name the exact id you have. When they name one you do not have, the body falls back to the cube and the line says a mesh was missing, rather than letting you believe the cube is what somebody built. A mesh is kept as long as any project names it; only past the space ceiling do the largest unnamed ones go.

The home-screen app opens without a connection. After one complete online visit, the page, code, geometry worker, fonts and all built-in shapes are kept as one version on the phone. A new version takes over at the two moments nothing can be lost: when the app opens, before the first touch, and when it comes back from the background — the project was written as it left. It never reloads a drawing under your finger. (It used to wait until the app was closed, and a home-screen app on iOS is almost never closed, only suspended, so new versions never arrived.) Imported meshes stay in IndexedDB. The first visit still needs a connection, and clearing website data removes the offline copy and every project with it — the browser's copy is the only one until you press LAGRE or share.

The last view and shell setting are remembered too. A small synchronous receipt holds the latest settings until IndexedDB commits them, including when iOS suspends the app during a write. Startup finishes reading the session before autosave begins, so a slow database cannot replace your work with the default cube. Project ZIP files remain the portable backup.

The body

The built-in shapes are furniture and animals. A sphere, a cylinder, a cone and a torus were honest mathematics and none of them said what the tool is for. Ten stools and four sheep say it in one look. They live as glTF under public/form and are fetched when you touch one — 5.8 MB of textured model reduced to about 285 kB of geometry by scripts/former.ts, decimated to 25k triangles, which is under the 40k the build cuts to anyway. Their names are stable, so a project that names stolform-03 finds the same shape tomorrow — the only source that needs no bytes in the file, because it is the only one on the server rather than in somebody's downloads folder.

The menu lists the family, not the version. Ten stools were ten lines covering the object, and you had to choose between ten things you had not seen. One line says stolform and gives you the first; if it is not the one you wanted, the same line takes you to the next. A version id (sau-03) only ever means which file to fetch — it is what the scene string and the project carry, and lib/scene.ts is where a family turns into one.

And bla, bottom left, is that in one tap. Through the menu it is two taps with the body covered, every time, to answer the one question — is this the right stool? With a piece selected in the body tool, bla stands opposite the tools, under the other thumb, and takes it to the next version where it stands: same spot, same size, same turn. It is only there when the family has more than one version — a cube has no next — and it goes in the same way the menu does, so undo and the project see the swap they have always seen.

A layer is the bond between a piece and its planes. Two figures that overlap are one body, and a plane through both gave one rib reaching out of the first, across the air, and into the second — a single part holding two figures together where you wanted two. Give the piece a layer (the row of LightBurn colours under the size, with the piece selected) and give a plane the same layer, and the plane belongs to that piece: its profile is cut to that piece's box and stops there. The box is the one already drawn around the piece, and a marked piece is drawn in its layer's colour so you can see what belongs to what.

Several pieces can carry one layer — then the planes on it are cut to all of them. A layer no piece carries clips nothing, and an unmarked plane cuts the whole body: that is what every project made before this still does, and what the layer has always meant on its own — a colour in the cut file.

The cube stays, and it is the only one made in code: it is the default object and the fallback when a source is missing, so it has to be on screen before anything has been near a network.

The body is a list of pieces, not a file: shapes made in code or fetched, and files you dropped in, each scaled to 100 mm on its longest side times its own size, turned about z and placed, then the whole list is rotated, scaled to storleik and set on the floor. Nothing is stitched: the rays count shells, so two pieces that overlap are one body where they overlap. The list is the scene string in the parameter bag, and the project file carries every piece's file.

One drawing of the plates, not three. The sheet panel used to carry a 160-pixel thumbnail of the same drawing, and the contour view a WebGL ribbon of the same profiles again — the same picture three times, and only one of them could be worked in. Both copies are gone, and with them a third slice, a contourLines pass over every rib, and up to 52 kB of SVG serialised across the worker boundary on every parameter change.

The sheet view has a scale. A measuring grid lies under the parts: the step follows the eye, not the sheet — the smallest of 1, 2, 5, 10, 20, 50, 100 … that still leaves nine pixels between lines — with every fifth line stronger and carrying its number in millimetres. It is screen-only. The cut files have two colours and not one more, and a helper line in one of them is a layer somebody eventually forgets to switch off.

The sheet is often an offcut, so it takes the size it actually is: width and height go down to 100 mm in steps of 1, as does the body's size. They were steps of 10 from 200, which meant a 437 × 285 mm remnant did not exist — and rounding up promises the machine more material than you own.

The list holds 64 planes, and says so when you reach it. That ceiling is measured, not picked: pnpm tak puts it at roughly 15 ms per plane sliced plus 1.5 ms per joint, so one geometry change is about 0.8 s at 32 planes and 2.0 s at 64 on a workstation — three to five times that on the phone. Below about forty planes an edit stays under a second there.

Planes

A plane is a name, a point and a normal, in the body's own space. The point is stored as fractions of the box around the body, so resizing keeps a plane where it is on the body. The normal is a unit vector — two angles would have a pole. The whole list is one string in the parameter bag, so undo, the project and the project file all carry it with no extra code, and a hostile file cannot push anything but a valid plane into the geometry.

Symmetry is three switches at the top centre, one per axis. They change what skjer does: one press locks the plane you are aiming and its mirrors across the body's centre planes — x gives two, x and y give four, all three give eight. A plane that is already symmetric about an axis mirrors onto itself and is added once, not twice, so a cut down the middle stays one part.

What comes out are ordinary planes with ordinary names. They are not a group and not a copy: move one, re-angle one, mark one, delete one, and the others do not care. That is deliberate — a symmetry that persisted would have to share a name between two parts, and the name is what is engraved on the plate. So the switches are an aid to placing cuts, and then they are done. For the same reason they are not in the project: they say what the next cut will be, not what the body is.

Names belong to the part, not to its position. A plane is numbered when it is locked and the number is never reused, so 7 stays 7 while it is nudged, re-angled and redrawn, and the 7 engraved on a plate in a pile matches the row on the screen. A plane cut into several islands gets letters: 7a, 7b.

The split is a slider, and then a hand. ledd says how far into the overlap two planes meet — half and half at 0.5, so the two slots are equally deep. But a joint is two plates, and sometimes one should carry and the other only hold. One joint can be set on its own, and setting it deepens one slot and shallows the other by itself: the bottom of A's slot and the bottom of B's are the same number, read from either side of the same line. Nothing keeps them in step; they are not two values.

Draw a face where there is nothing. The first tool in the column (T) makes something out of nothing; everything else changes what already stands. Choose tom arbeidsflate in the body menu to start drawing with the source shell hidden. Choose firkant for a dragged rectangle or kontur to draw the whole outline with one finger. Release to close it and create an editable plate. The contour is simplified to at most 24 handles; tiny or crossing outlines are rejected. Freehand simplification is measured in screen pixels, and may relax to 1.25% of the outline diagonal at the point limit. It is input simplification, separate from the accuracy of the cut slots.

The outline follows the finger without rerendering the studio on each move, and its width and height in millimetres appear while you draw. Releasing selects the new face immediately: its corners are ready to shape. Only the finger that started the outline may finish it; lifting another finger does nothing to the drag. A cancelled touch or switching away from the app discards the unfinished outline. The final position is read from the release itself, not from an earlier rendered frame.

It used to be a tap per corner and one more on the first to close: five actions for the start of the work, and the start was all it ever was. Every corner is a handle in the outline editor the moment the face exists — drag it anywhere, add points on the middle marks, turn a corner into an arc — so the chain gave nothing the handles did not already give, and charged five presses for it. One drag, and the shaping happens where shaping happens.

The cost is that a lone finger does not turn the view while the tool is on, which reverses the reason the chain existed. That is a price a mode may take: it lasts one drag and then lets go of itself. Two fingers still belong to the object. A press that does not travel the same twelve pixels that make a drag anywhere else is a finger that did not move, so the tool stays armed and waits rather than making a face you cannot see.

The sketch plane is frozen when the drawing finger lands, and the face is drawn on the plane that faces you — the sketch plane is sighted along the view axis and projects to a line, which is nothing to put a corner on. Frozen, because a plane that follows the camera moves the face under your hand every time you turn to see where you are, and you find out only when you are done. Before the stroke starts, the view cube can still choose the drawing side. Views within 3° of an axis create exactly axis-aligned plates, including the top view. spegl x/y/z on a selected plate mirrors its outline, holes and curves into the new local frame. It creates a copy across the construction centre, or reflects a flat plate in place when both lie in the same plane. dubler preserves the full profile and selects the copy for moving.

The profile is a proposal, and form takes it over. The contour is the mesh read off, and sometimes that is not the rib you have in mind. Select a plane and press form in the thumb column (or O): the profile freezes into points, and every point becomes a handle in space you can drag. From then on the outline is the profile — the body is not read for that plane at all — so the shape can get smaller, which a mark added as material never could. Strokes are still drawn in it and slots still cut in it, exactly as before, and the joints are read off it like any other profile.

What freezes is the largest ring, and only that one: a profile can be several pieces with holes in them, and an outline is one polygon. That is the decision that lets the points stay points you drag instead of a tree you navigate — holes and islands you draw back with strokes.

Every edge with room on it grows a small round mark at its middle. Drag one and it becomes a point — one motion, not two: you pull the edge where you want it and the point came into being on the way, in the right place in the ring. The marks appear only where the edge is long enough on screen for a finger to tell the middle from the ends, so a four-sided box sprouts them and a dense eighteen-point rib does not. They also disappear under anything that covers them — the sheet, the tool column, the plane's own handles — because a mark you cannot reach is worse than no mark: the press goes to whatever is on top. (Measured before that rule: a point dragged out to the right ended up under the tool column, and the double-tap meant to reach it duplicated the plane instead.)

Double-tap a point and it becomes an arc. The outline stops being a corner there and the edge curves through it — and a second double-tap makes it a corner again. The mark says which it is: a square stands for a corner, the same square turned an eighth of a turn stands for an arc. That is the whole control. There are no handle arms: the curve is worked out from the point's two neighbours, which means it passes through the points you already set, the handle stays on the edge it steers, and there is nothing extra to miss with a thumb.

Only points live in the string. The arc is a flag — which positions in the outline are arcs — and the curve is turned back into points before any geometry sees it, so contour, the cut file and the joints read the polygon they always read. Those points are subdivided by how far the curve strays from the chord, not by a fixed count: they go straight into the field, where every edge is walked for every cell of a grid up to 520 × 520, so a flat eight steps per segment turned a 24-point outline into 192 and made the build four times dearer — on the worker, on every number you drag. Split on the deviation instead and a gentle arc on a dense rib takes two segments where it took eight, while a rounded corner on a long edge still gets the ones it needs: 32 outlines with every point an arc went from 2013 ms to 728 ms, and pnpm tak now holds arcs to under twice the cost of none. An outline with no arcs is, segment for segment, exactly the polygon it was before this existed: a corner is its own neighbour, which makes the stretch between two corners come out a straight line from the same arithmetic, with no second path through it. That is also why an old project opens the same shape.

Put a finger on a point and you are holding it — the same motion that starts a drag, so selecting costs no extra press. The one you hold reads in full ink. Then the keyboard has it: the arrows move it one millimetre in the profile's own frame and ten with shift, B switches it between corner and arc, ⌫ removes it, Esc lets it go. On the phone, where there is no ⌫, a long press removes it — that is where removal went when the double-tap was taken over, because a curve is something you make with your thumb on the point you are looking at, and the short way should go there. Holding shift while dragging locks the drag to one axis, which is how you get a straight edge by hand. None of that is magnetism — nothing snaps on its own guess; you hold a key and it does exactly one thing.

Three points is the floor. Below that there is no surface, and an outline that vanished because you removed one point too many is not an outline you can work in, so the press after the third simply does nothing.

The line you are shaping is drawn from the points, thin and dimmed, on top of the profile the engine returns. The engine's answer is the truth — it is what gets cut, with slots and strokes in it — but it comes back a couple of hundred milliseconds later, and a point dragged while the line lags behind your finger is a point you do not believe you are moving.

Double-tap it and the outline becomes the box around itself — a rib through an animal is a contour with ears and hooves, and sometimes the plate is what you want. Four corners, and they are handles like all the others, so you drag one out and have a trapezium. One more press and the outline is let go: the profile is the mesh again.

The points live in the plane's own frame as fractions of the size, in p: in the plane string — and which of them are arcs in r:, as positions — so undo, the project and the project file carry them with no extra code. There are at most 24 of them: a handle is 44 pixels and a profile filling 300 of them has a perimeter of about 800, which is eighteen handles that do not sit on top of one another. Past that you are tracing, not shaping. Projects written before this still carry the old f:1 mark and still get the live box.

forenkl in the thumb column is that count as a drag. A traced outline comes back at the ceiling and most of those points are the hand, not the shape. Hold the icon and pull up: the outline drops a point every twelve pixels, and the number stands in the reading at the top left while the thumb is down. When the column runs past the sheet it breaks into a second column to the left instead of off the bottom, so a tool never has to share a button or shrink to fit. It is the same distance-to-the-chord measure the contour was drawn with, run to a count instead of to a tolerance, so every point it keeps is a point that was already there and the corners go last. Pulling back down returns detail, but only as far as the outline stood when the drag began: the stroke it was simplified from is kept nowhere, so further back is undo's job, and the whole drag is one step of it. The handle only stands there for a plane that carries an outline, because there is nothing to simplify otherwise.

mjuk rounds the edge, in the sheet under the plane list: a mesh is triangles and the triangles show up in the profile, so the field is blurred before the contour is drawn — a straight side is untouched, corners round off. It is blurred before the slots, so a rounded corner never makes a rounded joint. It takes the whole group when a group is selected, like the layer. Smoothing is a fraction of the longest side, capped at two percent: past that it eats the legs off a stool, and it dissolves joints before it dissolves the shape.

virr shoves a row out of line. A grid is even, and even is honest — but a row of ribs standing evenly to the millimetre is also a row nobody has touched. With a group selected, the sheet grows a row that pushes every plane in it along its own normal. The kick is a hash of the plane's name, not a throw of the dice, so dragging back returns the row to where it stood (measured: 0.03 mm of 150), and the kicks are centred on zero so the row does not drift sideways while it wobbles. It is written into the points, like everything else the hand does: what the project keeps is where the planes are.

Every kept plane is editable, down to its outline. Nudge and re-angle with two fingers or the handles. Select a part and the thumb column offers skjer hòl: a round that cuts material away, dropped at the centre of the section and then moved, resized and turned with three handles. It is cut in the same field as the slots, so a hole you drew and a slot the engine cut never disagree, and the section shows the real result while you drag. When the model changes underneath a stroke, the stroke stays: it is what you did, and the tool does not throw work away unasked. It may drift out of true, and then you see it in the profile and remove it yourself.

Up to 64 planes. Beyond that a file is trying something.

Tenons

A drawn plate that stops at another plate is fixed to it with tenons. A slot needs both plates to pass through each other. A stool is not built that way: the legs stop under the seat, the rail stops at the side. Where an edge meets a face, a tenon goes through a mortise, and the engine finds those meetings the same way it finds slots — from the material, not from a tag. The plate with material just inside the near face of the other and none past its far face stops there; the plate with material on both sides passes through. The first gets the tenons, the second the mortises.

The edge is straightened. A finger does not put an edge exactly on the underside of a seat, so anything from half a thickness short to half a thickness past the far face reads as "stops here". Every outline point in that band is moved onto the near face — the sides stay straight up to the shoulder — the material past the near face is clipped, and each tenon runs through to the far face, flush. The plane string keeps what you drew; the section is the truth, as always. A mesh-derived rib never gets a tenon: an edge the mesh gave is where the mesh ended, an edge a hand drew is a decision.

A tenon can show. An edge drawn a little past the far face — up to two thicknesses, and never less than ten millimetres — is not a plate passing through but a tenon that sticks out: the material past the near face is clipped as before, and the tenons run out to the furthest edge the hand drew, to the half millimetre. Further than that, the two plates cross and get a half lap. A seat drawn between two sides, flush with their outsides or fifteen millimetres past them, gets four tenons either way.

A bent plate takes tenons too, where it meets a flat plate along a generator line — straight in both parts. A saddle seat between two sides ends at them like a flat seat would, and its tenons point along the tangent where the arc meets the side. Where one plate sticks out through the other, that stretch is protected: the other plate does not also read it as an end.

A tenon that shows far enough takes a wedge. From one and a half thicknesses of protrusion, the tenon gets a hole across it, half a millimetre inside the far face so the wedge bears on the face and a tap tightens the joint: one thickness wide along the line (the wedge is cut from the same sheet) and up to a thickness along the tenon, with at least a thickness of material left beyond it. The wedge is its own part in the cut list — four thicknesses long, straight on the bearing side, six degrees on the other, engraved with the tenon's name (k3-1-0) — with no plane of its own, so the montage leaves it aside. Under six millimetres a wedge is a splinter, so 3 mm models get none.

Or every tenon takes one. kilar in the material tab (kilar, 0 or 1) makes every tenon that goes through show, half a millimetre under two thicknesses, whatever the hand drew — a seat flush between its sides, a rail ending in a side, a leg ending under a seat — and each gets its wedge: the hole is then a thickness square and a thickness of material stands beyond it. A tenon drawn to show further keeps its own length. Off, the drawing decides as before.

And along an arc. A bent seat whose cylinder axis runs from side to side meets each side in a circle — straight in the seat's unrolled pattern, an arc in the side. The seat gets its tenons as always; the side's mortises follow the arc, built from short boxes whose sagitta stays under a hundredth of a millimetre, and the wall check and pnpm ledd read them along the arc, not along the chord. A saddle curving front to back between two sides is a seat like any other.

A corner is fingers. Two plates that each end flush with the other's outside — the sides of a box — cannot hold a mortise. The corner is split into an odd number of fingers along the line, about six thicknesses long and never fewer than three, alternating between the two plates, each running out to the other's outside face. The end fingers belong to the later plate, so where three plates meet (a seat flush on a box) the seat owns all four corner cubes and no side claims one. Each plate goes in along its own normal.

A split seat on a rib is not a finger joint. When two halves of a seat meet over a rib, along the rib's own mid-plane, the rib carries both edges: no fingers between the halves there, and each half's tenons stop at the rib's mid-plane, so the two share one mortise from either side. Only the stretch the other half actually covers is stopped short; where one half is alone over the rib its tenon runs through and takes its wedge. With the rib ending under the seat the corner fingers are laid out from the rib, and the split plate always takes the odd ones, so both halves see the same rhythm whatever order the planes are listed in.

A rail goes through. Where one plate is narrow along the meeting line — a rail's cross-section — and the other has material well past it on both ends and on both sides, a half lap would cut the rib from its edge all the way in to the rail. Instead the rib gets a closed mortise the size of the rail's cross-section plus clearance, the rail is left whole, and it slides through along the rib's normal. Seven slats with a rail through them are seven holes and no slots.

Tenons follow the length, not the plate: one per 150 mm of meeting, with shoulders of at least half a thickness and fifteen percent of the cell, so a 300 mm seat edge gets two tenons with material between them. A mortise is the plate thickness plus the clearance wide — divided by the sine of the angle, plus the extra a slanted tenon sweeps through the other plate's thickness — and the tenon length plus the clearance long.

The corners are corners. Tenons, mortises and the clip are placed in the field after it is refined, with grid lines on their edges and a thousandth of a millimetre inside the convex ones, and the outline is read exactly on that grid rather than interpolated onto it. Measured on the reference stool: every mortise and every tenon within 0.0000 mm of its nominal width, and the drawn corners of a leg within 0.02 mm — they used to come out with a two-millimetre chamfer, one grid cell. The simplifier holds each box wall the way it already held slot walls.

Direction carries a sign. A slot is a line — a part can come from either end and the mouth is put where it comes from. A tenon is an arrow. A rail with tenons into two sides facing each other has two directions, not one, so it goes in after the first side and before the second, and the seat comes down last — and the engine finds that order itself (see Assembly).

pnpm ledd checks every tenon in the cut profiles: material in the tenon and right inside its tip, none past the tip or beside it, a wall on all four sides of every mortise, and the tenon and its mortise at the same point in space — on a straight stool, a stool with a raised seat, over-long rails, a narrow seat, a 3 mm model, splayed legs (seat first, each leg along its own tenon), crossed legs with a seat, where slots and tenons share one object, a seat between the sides, flush and with tenons showing, a bent saddle seat flush and showing, a box of four sides with a flush seat, joined by fingers, seven slats with a rail through them, a seat bent between the sides with curved mortises, and a seat with wedged tenons.

The plane, flat

2d in the thumb column opens the selected plane lying flat in its own frame, with millimetres on it — a vector editor for the outline and its holes. Drag a point (it snaps to whole millimetres, and to its neighbours' x or y within six pixels); tap the small dot in the middle of a segment for a new point on the curve; the grid is on when the surface opens and its step stands in the reading — rute 20 mm — which is also the switch that takes it away; the step is picked so the lines never crowd closer than nine pixels, so a pinch subdivides it the way a drawing program does, every fifth line darker and the two axes darker still; rund turns the selected point between corner and arc, slett punkt takes it away (three is the floor). With spegl on — it starts on for an outline that is already symmetric — every edit happens to the point's mirror partner across the centre line too. hòl draws a contour inside the outline, firkant and sirkel drag a box; a hole is dragged to move it and slett hòl removes it. blyant draws over the outline: start the stroke on one of its points, end on another, and the piece of outline you drew along is replaced by what you drew. Which of the two pieces between those points goes is decided by the geometry and not by the direction — the one whose middle lies nearer the stroke — so the same curve drawn backwards gives the same plate. The stroke is thinned with the contour's own measure, the two points you began and ended on stay exactly where they were, and the new points between them come back as arcs where the stroke curves and corners where it does not. It is the one tool here that reshapes instead of adding, and it is what the flat surface is worth opening for after a freehand contour: the contour tool gives the whole ring in one stroke, this gives one edge of it. Two fingers pan and zoom, and the view holds still while a finger is down. A drag is one change: the draft lives on the flat surface and goes to the parameters when the finger lifts.

With nothing selected the bar offers del i to — the plate split down the middle into two plates edge to edge, which the engine joins with fingers — or, when the split lies on a rib's mid-plane, with the rib (see Tenons) — kneik, the same split with one half folded 90° about the line so the plate turns a corner and stands as an L, and spiler 3 4 5 6: the plate cut into that many equal slats with a thickness of air between them. The slats run the way the plate reaches other plates: a seat between two sides reaches them along one axis, and each slat runs from side to side with its own tenons at both ends; a plate that reaches nothing is cut across its long axis. The first slat keeps the plate's name, the others take the next free ones. The edits are plain functions in lib/vektor.ts, checked by pnpm teikn.

A picture becomes a plate

Pick an image where you pick a mesh. The dark is material, the light is air: the picture is read as brightness (transparent counts as white), smoothed, and cut at a threshold, and the zero line is the outline — the largest outer edge — with the holes inside it as drawn contours, largest first. A drag across the picture works like the grid: sideways is the threshold, up and down the smoothing, and the traced shape stands there the whole time with its point and hole count. snu makes the light the material. legg inn puts the plate in the plane you would draw on — through the middle, facing you — at four fifths of the workspace. Where the outline runs round, its points are arc points; dust smaller than a thousandth of the picture falls away. pnpm teikn traces a ring with a square hole and a speck of dust.

Bound by the mesh, or not

A plane without an outline takes its profile from the body. A plane with one takes it from the outline alone — so a drawn shape can reach past the body. The nett word in the thumb column switches between the two: on a plane with an outline it binds the outline to the body, and the profile is what is inside both (a drawn silhouette cut to the animal where it runs past it); on a plane without one it freezes the section into an outline, which is then free. The flag is n:1 in the plane string and means nothing without an outline. pnpm ledd checks that an outline twice the size of the cube gives the cube's section when bound, and the whole outline when not.

Drawing furniture

An empty workspace is a piece of furniture. Half a metre, twelve millimetres, a half sheet of plywood (1200 × 600) to cut it from, the front view facing you and the contour tool ready; the view waits for the body to reach those dimensions before it frames it. Each of the three numbers is set only if it is still at its default: a size, a thickness or a sheet you chose stays.

• A seat lands. A plate drawn from above settles with its underside on the tops of what it covers — but not on an edge it barely reaches: an edge counts only when at least a thickness of it lies inside the footprint. A chair seat drawn to the back leg overshoots it by a few millimetres, and that is a finger, not a leg to rest on: it lands on the rail, and the leg passes through it as a joint. A box wall flush with the seat's edge has a long top inside it, and bears.
• A rail is held. A plate drawn from the side with its ends in two plates seen edge-on is placed where those plates have material along its whole height: a rail under the seat stays where it was drawn, a chair back slides to the back legs. The side view cannot say how deep, so the sides answer.
• Ends snap. Drawing from the side, a point within a fingertip of the floor or of a plate seen edge-on locks onto it — and onto the corners of that plate: from above a chair side is a line, but the front of its back leg is a point on it, and a seat drawn to it ends there. An axis the snap has set, the centring leaves alone.
• Four ways to draw: firkant, rund, halv, kontur. rund is one drag like the rectangle, and what it leaves is eight points on the ellipse, every one of them an arc point — so the curve runs through them and every one is still a handle you can drag. A round table top, a round seat, an oval plate.
• A bent plate is a cylinder all the way to its edges. The flat faces were subdivided along the curve but the side walls were not, so each edge ran as a straight chord through the solid and cut up to 38 mm inside the cylinder at full bend — the plate read as a sail with a crease. The walls now follow the same subdivision, and every edge midpoint sits within 0.05 mm of the cylinder.
• Plates in the same plane are not "too tight". Slats in a split seat, four quarter-shelves around crossing sides — they lie in one plane, and the gap rule used to read the distance between their planes as zero and call it twelve millimetres of overlap. Two plates in the same plane are the same surface; whether they collide is a question about their outlines, not about the distance between them, so the rule now skips the pair.
• halv draws one side and mirrors the other. Trace the silhouette down one side of the centre line and release: the curve is simplified to a dozen points and mirrored into a closed, exactly symmetric outline. An X-shaped leg, an hourglass waist, a wave — half the finger travel, and symmetry you cannot draw by hand. Cross the centre line and the waist pinches to nothing, which is what a pinched waist means. The whole mirrored ring is drawn while your finger moves, so you watch the shape close as you trace it, and the measurement reads the full width, not the half you drew.
• The shape follows the group too. Reshape one wall of a ×4 box and all four take the same outline; release the shape and all four release it. Form, 2d and nett used to vanish while a group was selected, so the only way in was to undo the group first.

Assembly

The list order decides the slots. A part slides in along its slots, and a plate can only go one way: when a part comes in, every part it meets that is already placed must agree on the direction. For a slot pair the part later in the list comes downward where the line has a vertical component, its slots open in the direction of travel and the earlier part's open toward it — exactly what the rib grid always did, X family slots up, Y family lowered onto it.

The assembly order is read, not written. Every joint says which way each of its two parts moves if it is the one that comes second: along the slot line, or along the tenon, or down onto it. The list is what you drew, in the order you drew it — two sides, then the seat, then the rails — and that is not the order anyone assembles a stool in: a rail has to go in between the sides before the second side goes on. So lib/orden.ts reads the list first; if it goes together, it is the answer. If it does not, it looks for another order in the same directions — greedy, one step ahead, the part that blocks fewest of the rest first — and takes it if fewer parts are stuck. The slots do not move: a part that comes in before its partner simply travels the other way along the same line. The montage and montering.txt read that order.

Where no order works, the hard rule kan monterast names the part, and if reordering the list would fix it — the one case the reading cannot reach, because a list order also turns slots round — the button does that. Three planes that cross each other in material without sharing a common line cannot be assembled in any order; then it is the plane, not the list, that has to change. montering.txt in the ALT bundle writes the order out, part by part, with the direction each comes in.

And you can watch it. montasje is the fourth view, in the top bar next to flate, lag and kontur (or 4, or M): it puts the parts back on their plates and lets the body rise out of them, one group of ribs at a time. It was a tool in the thumb column, and it was the wrong kind of thing to have there — every other button in that column rewrites the planes, and this one changes nothing at all. It is a way of reading the same object, which is what the other three words are. Its column carries one control, the step: drag it up and down to stop anywhere in the animation, because an animation you cannot stop in the middle is an animation you have to watch four times, and tap it to play the whole thing again from the plate. The line over the object reads which round you are in and how many ribs are in it. Any other view — or escape — leaves it, and the object stands where you left it.

The order is not a second opinion. It is montering.orden — the same order montering.txt writes and the kan monterast rule guards — grouped into steps: two parallel planes never cross each other, so as long as the direction holds they go down together. A rib grid is two steps, across then along. A vortex is one step per rib, which is the truth about a vortex. Parts with no joint at all are not in the order — nothing holds them — so they come last. pnpm probe walks the order end to end and requires the step never to go backwards: if it did, the animation would be showing you a different assembly from the sheet in the box.

A part is one mesh and two matrices. The outline is the same points in both places — the assembly puts them in the plane's frame, the nester lays them on a plate with a quarter turn and a shift — and both are rigid: akser gives u × v = n, so the frame is a true rotation, and all four quarter turns in the nester have determinant +1, so a part is never mirrored. So the part needs one mesh, in its own flat frame, and two matrices: where it lies and where it goes. Everything between them is interpolation, not new geometry. pnpm probe multiplies each part's mesh by each matrix and requires the answer to be exactly the two meshes the engine writes to the GLB and the flat GLB — worst error 2.4e-4 mm, which is float32 and not geometry.

The plates lie in a stack, centred under the body, not spread out side by side the way the flat GLB writes them. That file is something you look through, where nothing should sit on top of anything; this is your body standing up out of its own plates, and there the pile on the bench is what is true. Twelve plates side by side is three and a half metres against a 150 mm body, and the object is a dot in that picture. The stack is centred on the parts, not on the plate: a 600 × 400 sheet under a 150 mm body would be four fifths empty.

Parts laid flat always take more room than the same parts crossed into each other, so the view scales down to hold both ends of the animation — the camera does not move, the picture does. Opening the tool is asking for that, which is the one thing that sets the frame. A bent plane is the single part that is not a rigid move of itself: it is cut flat and stands curved. It flies flat — which is what it is on the plate — and becomes what it is as it lands.

Two rib languages

Ribbed plate furniture speaks two structural languages, and the tool has a layout tool for each. The grid crosses ribs over one another, under your thumb. The vortex — the second button in the thumb column, right under the grid, or V — stands them around the upright axis: n ribs, each turned 2πi/n, each pushed out so it is tangent to a circle rather than passing through the middle.

The push is the whole thing. Ribs that all pass through the axis cross each other along the same line: measured, twenty of them collapse to two parts and thirty-six loose pieces. Pushed out, the same twenty give a hundred joints and nothing loose. So the offset is clamped above zero, and the two numbers are coupled — three ribs at a large offset stop meeting altogether, which is why the line keeps telling you how many parts came out while you drag.

The offset is a fraction of the body's narrowest width, not of the bounding box. That distinction is not pedantic: a plane's point is stored as fractions of the box, the box is not square, and the same fraction on both axes traces an ellipse in millimetres. On a 300 × 120 mm body it swung the ribs between 21.6 and 54.0 mm from the axis — two and a half times — and the vortex stood lopsided. Dividing each axis by its own width holds it at 43.2 mm all the way round.

The grid

A rib grid is two numbers, and rutenett is the tool that sets them with your fingers: sideways is columns, up and down is rows, 44 px to a plane. It starts from the grid that is already there, so it carries on where yours left off.

It only ever takes its own. It owns the planes a grid would have made, and it recognises them by their geometry alone: normal along x or y, centred on the other two axes, and the n of them spaced evenly on (i + ½)/n, with no bend, no stroke and no layer. Everything else in the list is yours and stays — its name, its strokes, its layer, its place on the sheet. It is all or nothing per axis: move one rib out of the row and the whole row is yours, because n ribs unevenly spaced are not a grid of n; the tool then starts from zero on that axis and lays its own beside them. So the grid's names and groups begin after yours, and its ceiling is what is left of the 64.

It used to rewrite the list — a grid was a list and not an addition — and ten planes you had cut by hand were gone the moment you touched the tool. Either way the whole drag is one entry in undo, however far the fingers went, and Z gives back the planes you had.

There used to be a search here that sliced a dozen grids for real and ranked them, and a deep search that measured the body and walked a front. It answered a question nobody had asked — the two numbers were never the hard part, and a ranking is not a decision. The tool that sets them is.

Projects

The work is kept as projects in the browser: a name, the parameter bag, the view and the shell switch, written as you go. The list is the first tab in the drawer — prosjekt, beside the cut list and the settings, and the first line of the body menu — newest first, with when each was last changed. Tap one to open it; nytt, dupliser, slett and namn sit below. Delete takes two presses, the first asking sikker? for three seconds, because it is the one action here nothing undoes. Switching writes the project you leave before it reads the next, and the undo history does not follow you across: another project is not an edit.

Why projects and not the link: a link that carries state is a second copy of the truth, it cannot carry a mesh, and since the app rewrote it on every change, a reload always trusted it over the database. Why not only the project file: a file is something you have to remember to make. So the browser remembers, and the file is what leaves it — LAGRE writes it, the share button shares it, and opening one makes a new project of it. The name is a text field with a caret, like the number field and the paste field in the settings: the drawer sits over the object, so the keyboard hides nothing you are looking at.

Output

STL	the assembled stack, as one soup of triangles
GLB	the same stack as glTF binary — metres, Y up, flat-shaded: Blender, Sketchfab, a browser. One node per part, named by the address engraved on it, under one group that is the assembly: the stack comes apart with a click
FLAT	the same parts again, laid flat exactly where the nester put them — one group per sheet, ark-1, ark-2, each part a node named by its address, sitting on the floor from 0 to the plate thickness. The cut job in three dimensions: already exploded, already arranged, already flat. The outline is the nominal one — kerf is taken in the cut file and only there
3MF	the same flat parts for a 3D printer — one object per part, named by its address, millimetres and Z up, welded and watertight. Bambu Studio, PrusaSlicer, Cura: drag it in, press arrange, print. A slicer does not read GLB, which is the whole reason this file exists
USDZ	the same again for AR Quick Look: share it on an iPhone and the assembly stands on the table in front of you, at size
DXF	R12 ASCII, mm, layers KUTT and GRAVER, kerf-compensated — one file per nested sheet, zipped when there is more than one. The plate is the drawing: $EXTMIN/$EXTMAX, not a burnable rectangle
SVG	every profile side by side, 1:1
ARK	one file per nested sheet, 1:1 — zipped when there is more than one
PNG	the same sheets as pictures, for messages and the wall — not for the machine
PRØVE	fit-test coupon: seven slots, each 0.05 mm wider than the last
BØYEPRØVE	score-test coupon: five fields, each scored at a different row spacing, the spacing engraved under it
ALT	the whole job in one download, plus the cut list as CSV and the assembly order as text
LAGRE	a project file — settings and every mesh together; the share button shares the same file

The twelve files stand in three rows, not one heap — rom, plate, alt, with the word in the margin where the slider groups keep theirs. A row says what a file is for before you read its name: whether it is to be looked at or printed, cut, or carries the whole job. The two colours are explained under the row they belong to; they used to sit at the bottom, next to lagre, explaining nothing near it.

On the phone the box stands above the sheet, not inside it. It used to sit inside, positioned over the sheet's top edge — and the sheet clips, so the box had a size, a position and every one of its buttons and drew nothing at all. Every ordinary check passed: it was in the DOM, aria-expanded said open, it had a bounding box. pnpm panel uttaka asks the one question that catches it — what is topmost at the middle of the chip.

In the SVG files colour is the operation, and the colour carries the order: #000000 engrave, #0000FF cut. Those are LightBurn's C00 and C01, and LightBurn runs layers in list order, so black runs first — engraving has to happen while the part is still held by the sheet. Two colours and no more; nothing is filled. Which sheet a file is comes from its name.

The sheet view in the drawer is not a picture of the file; it is the file, engraved names included — drawn in the interface's ink, while the file itself is always black and blue on white paper. Drag a part and it stays where you drop it; the rest repacks around it. Hold a part to pin or release it, turn it a quarter, or send it to the next sheet.

Cut the fit-test coupon first. klaring and snitt are two guesses that multiply in every joint.

And the score-test coupon before you bend anything tight. Row spacing is the one number in the scoring the tool guesses rather than measures — everything else follows from the radius you set and the thickness you measured. Whether the ligaments survive the twist is torsion in a material that is not the same in two directions, and it is not read off the geometry. So the coupon is the answer, the same way it is for press fit: five fields at half, three-quarter, one, one-and-a-half and twice the table spacing, the number engraved under each. Bend each field to the radius you need. The coarsest one that survives is your spacing — fewest cuts, strongest part, shortest run. The pattern comes from the same function the real part is cut with; a coupon drawn separately would test something else.

Parameters

storleik	size	longest side, 40–1200 mm
rotX/Y/Z	rotation	±180°
glatt	smoothing	0–24 Taubin passes
trekant	triangle budget	0.5–60 k, by vertex clustering; 40 k by default
forenkl hol	cut profile	how far the cut may stray (up to 10 mm — a spiky scan needs the room), and the smallest hole worth cutting
scene	the body	pieces: source, place, size, turn, mirrors, as a string
plan	the planes	name, point, normal and strokes, as a string
lause	pieces with no joint	keep / drop
tjukn	thickness	1–25 mm
klaring	press fit	0–0.6 mm, slot wider than the plate
ledd	joint split	0.2–0.8
kilar	wedges	off: tenons as drawn; on: every tenon through shows and takes a wedge
snitt snittveg	kerf	0–6 mm, taken in the file or in the machine
fart	cut speed	for the time estimate only
arkB/H	sheet	up to 3000 × 2000 mm
fest	pinned parts	where a part stands on the sheet, when the hand said so
deling	split joints	how deep one joint cuts, 5-12-0:0.35, written by dragging its slot end on the sheet

Materials: plywood, MDF, acrylic, cardboard — density and surface.

Rules

The tool cuts anything, but it says what it cut. Hard means the parts can't be made or assembled; soft is a choice worth knowing about. Planes grip · parts exist · one way in for each part · every part hangs in a joint · material remains at the joint · parts fit the sheet · press fit · kerf · slot survives the kerf · room between planes · mesh closed · resolution kept · utilisation.

The table has one line per reading, coloured by the rule that judges it — and under them, the rules that judge something the table does not show: whether the parts can be assembled in any order at all, and the two sliders. Those appear only when they break.

Most broken rules carry their own way out: the rule that knows fifteen parts are too big also knows how much, so it offers prøv 290 mm and sets it — unless the parts were drawn by hand: a stool drawn at 450 mm is 450 mm, so there the advice is a larger sheet, prøv 600 × 450, the smallest in whole fifties that takes the worst part. Some carry none, on purpose. «Planes grip» and «parts exist» used to offer a 6×6 grid — one press and your plane list was replaced by a generated one. That is not advice, it is a different drawing; now that the grid tool sets the two numbers with two fingers, it is work a button has no business throwing away. Those rules state the reason and stop there.

How it works

GLB / glTF / STL / OBJ / PLY          per source, cached
  ├── weld        loose triangles become vertices with neighbours
  ├── unflip      an inside-out mesh is turned right side out
  ├── simplify    vertex clustering down to the triangle budget
  ├── smooth      Taubin low-pass — volume stays, noise goes
  ├── assemble    each piece scaled, turned and moved into one mesh
  ├── place       rotate, scale, centre, set on the floor
  ├── rays        which points are inside the solid?
  ├── planes      for each plane: turn the body so the plane is an axis,
  │               one ray per row and column, a signed field, marching squares
  ├── joints      where two planes share a line through material — slots cut
  │               in the field, oriented, widened by the angle between the planes
  ├── tenons      where a drawn edge stops at another plate — clipped at the
  │               near face, tenons through to the far face, mortises opposite
  ├── nest        parts packed by outline, holes counted as free space
  └── STL · GLB · FLAT · 3MF · USDZ · DXF · SVG · ARK

The nesting is what FLAT and 3MF are made of. A part laid flat is the part the machine cuts, at the position the machine cuts it — the same rings the DXF and the sheet are drawn from, extruded by the plate thickness. A bent plane lies flat as the blank it is cut from, before it is bent, because that is what the nester packed.

So the sheet size is also the print bed. The parts come out of the nester at arkB × arkH; set those to your printer's bed — 256 × 256 for a Bambu Lab A1/P1/X1, 180 × 180 for an A1 mini — and the 3MF opens with the parts already arranged on it. Leave the sheet at plate size and they land off-bed instead; that is one press of arrange in the slicer, not a problem, but the nester will have packed for a plate you are not cutting.

3MF is millimetres and Z up, which is what the workshop already is: nothing is turned and nothing is divided by a thousand on the way out. GLB is metres and Y up and has to be. The two look alike in the code and not in the file, and a part written 0.003 mm thick is a part you cannot see.

A mesh is a shell, not a solid. Rays make it one: count which way each triangle faces, sum rather than parity, because scans have overlapping shells and parity reads the overlap as a hole.

Two resolutions decide how the parts look, and they are not the same thing. trekant is the mesh budget — 40 000 triangles by default, which is what a scanned or modelled figure needs before it stops looking faceted. The sampling grid is the other: 220 cells along the longest side for everything that is measured, cut or drawn on screen (a coarser 120 while a finger is still moving, and the fine build lands when it stops). The screen and the cut file are built at the same number on purpose — the phone used to be pinned to the coarse level, so it showed stair-steps that were not in the file.

An oblique plane has no axis to shoot along, so the body is turned — a right-handed rotation of the vertex soup per plane orientation, cached — and the plane becomes an ordinary section with exact edge distances along every grid line. A grid has two orientations; a set of hand-placed planes has as many as you locked.

Slots are cut in the field, not in the polygon — the only way the cut file and the 3D view cannot drift apart. Hand-drawn strokes go into the same field, before the slots.

Nesting follows the outline, not the bounding box — raster-based, no genetic pass, because the sheet count has to keep up with a gesture.

Addresses are engraved as strokes, not text. A TEXT entity is a question about fonts, and the answer is often no.

The first four steps belong to the source, not to the body it stands in. They read the geometry of one shape and say nothing about where it is, so they are done once per source and kept. It matters when you drag a piece: every frame is a new body, and welding and simplifying all of them again because one moved four millimetres was 43 ms of the 65 a frame cost. It also makes the triangle budget mean the same thing wherever a piece stands, and it lets each source answer for its own winding — one inside-out shape of four used to be unfixable without turning the other three with it. The budget is split between the sources in proportion to what each brings in, so a cube of twelve triangles does not sit on ten thousand it has no use for, and one source is the whole ceiling exactly as before. Clustering per source is also finer than clustering the union, whose grid has to span the whole scene: two figures side by side now keep 19 700 triangles of their 40 000 where the old path kept 13 100. pnpm tak counts the cache misses during a drag — the number is exact on every machine, where a millisecond threshold is not.

Develop

pnpm install
pnpm dev
pnpm build      # forces webpack, then checks the worker actually bundled

Next.js + React Three Fiber. All geometry runs in a Web Worker; the main thread only draws — and computes the sketch plane, because that is the input.

Do not build with Turbopack. It ships new Worker(new URL(…)) as raw TypeScript in static/media, the worker dies silently, and the page just sits there. pnpm build forces webpack and fails if it happens anyway.

Every number the tool prints is read off the geometry. So is every check:

pnpm sjekk   # tsc --noEmit
pnpm probe   # engine without a browser: parts, joints, cut length, files
pnpm rekkje  # reads the cut files back: engrave, inner cuts, outline, in order
pnpm vrient  # meshes that aren't meshes, hostile plane strings, a hostile parameter bag
pnpm ledd    # every joint the panel counted, found again in the cut profiles — grids, oblique planes, bent ribs with floors
pnpm raad    # breaks each rule, presses the fix it offers, checks it worked
pnpm glb     # writes GLB files with known geometry and reads them back
pnpm pakk    # redraws every sheet and counts cells — catches overlaps
pnpm hand    # the plane list as a string: one edit leaves the rest, names never reused, pins hold
pnpm enkel   # the two simplification sliders take what they say and no more
pnpm tak     # the plane ceiling: what 64 planes cost, and that slicing stays linear in them
pnpm tung    # a million triangles in, and how long that takes
pnpm ark     # cut sheets as images
pnpm look    # screenshots of the page, and any console errors
pnpm panel   # the controls in a real browser: both surfaces, gestures, keys
pnpm teikn   # freehand input, concave outlines, axis snapping and persistence
pnpm presisjon # actual slot widths and kerf read back from nested SVG
pnpm redigering # mobile drawing, material numbers, mirroring and undo
pnpm webkit  # WebKit mobile layout and editing smoke test on PC, not physical iOS

probe through tak are headless and fast, and .github/workflows/vakter.yml runs every one of them on each push — the build first, since that is what catches a worker shipped as raw TypeScript. Point look and panel at next start on port 3210, never the dev server — they drive a real browser for minutes, and HMR reloading underneath produces failures that look real.

lib/core.ts	start here. The contract: parameters, metrics, rules, views
lib/plan.ts	what a plane is: name, point, normal, strokes (box, ellipse); the string; the grid and the vortex
lib/params.ts	the parameter space and its defaults
lib/scene.ts	the body as pieces: primitives and files, placed
lib/kropp.ts	the body: pieces joined, weld, unflip, simplify, smooth, place — and turned along any normal
lib/snitt.ts	planes to ribs: the field, the joints, the slots, the parts, the assembly order
lib/tapp.ts	tenon and mortise: where an edge stops at a face, and the boxes that cut it
lib/orden.ts	the assembly order, read off the directions every joint allows
lib/stykke.ts	lines through profiles: runs of material along a line or an arc
lib/montasje.ts	the way from the plate to the object: one mesh and two matrices per part, and the order grouped into steps
lib/bygg.ts	the whole build once: body, ribs, parts, nesting
lib/soup.ts	mesh in two forms, and the road between them
lib/io/	GLB, glTF, STL, OBJ, PLY readers
lib/mesh/solid.ts	the rays — a mesh you can ask questions of
lib/mesh/simplify.ts smooth.ts	vertex clustering, Taubin
lib/contour.ts	marching squares
lib/pack.ts nest.ts	nesting
lib/metrics.ts rules.ts	what is measured, and what is judged
lib/export-*.ts stroke.ts zip.ts	the files, the single-stroke font, ZIP both ways
lib/motor.ts	the engine as one object

The reasoning behind each decision lives in the file it belongs to. The comments are the documentation. REBUILD.md is the brief this version was built to.

Limits

• Draco- and meshopt-compressed GLB cannot be read. Re-export without.
• GLB and USDZ out carry the geometry and one colour, and nothing else: no normals (both formats shade the flat parts from the faces themselves), no textures, one material. The USDZ is ASCII USD in an uncompressed, 64-byte-aligned archive, which is what the format asks for.
• STL and USDZ out are one mesh, because the formats are: binary STL has no notion of a part, and the USDZ is there to stand on the table, not to be taken apart. Only GLB, FLAT and 3MF carry the parts separately, each named by its address.
• FLAT is a layout, not a job. It shows where the nester put each part; it is not cut from, so it takes no kerf and carries no engraving. The 3MF is the same geometry, so the same holds: what you print is the nominal part, not the kerf-compensated one.
• The 3MF carries geometry and names, and nothing else — no printer profile, no filament, no plate type, no per-object settings. It is a generic 3MF, not a Bambu Studio project file; the slicer supplies all of that when you open it.
• A printed part is not a cut part. Thickness, clearance and kerf were set for a plate and a laser. Cut the fit-test coupon's logic again for your printer: klaring is the number that decides whether the joints press together, and a printer's tolerances are not a laser's.
• A .gltf pointing at a separate .bin cannot reach it from a browser. Use .glb.
• A globally inverted mesh is fixed automatically; inconsistently wound triangles are a real defect and need repairing elsewhere.
• Two planes closer than five degrees to parallel do not get a joint: the slot would be twelve plates wide.
• Three planes that cross in material without sharing a line cannot be assembled in any order. The rule says which one — and montering.txt leads with it rather than printing a numbered sequence that stops partway. Nothing blocks the cut: the tool does not decide for you, and there are reasons to cut the parts anyway. But it will not hand you a list that looks like a plan when it is not one. The export chips carry the warning colour and name the broken rule, and the ALT zip carries reglar.txt — the tool's own reading, written where it survives the session. None of it stops the cut.
• One tap presses every advice that is safe. Each rule has always carried its own fix; that is enough while one thing is wrong. An object with forty-eight planes can break six rules at once, in an order nobody told you, where each fix changes what the others answer. fiks alt runs them one at a time, recomputing between, never taking a fix that raises the number of hard breaks, and stopping when nothing changes. It is one step in undo. It skips any fix that destroys work — "remove the ones that are stuck" keeps its own button, because a tap that deletes forty planes should be a tap you meant.

Credit

Scene, gestures, panel and shareable URL come from 50x50x50.iverfinne.no.

Licence

MIT — see LICENSE.