every version · newest first
changes.
What's new in each version of the okay designer, and a download for every one. The web app at okaydesigner.com/app is always the newest; the Mac app tells you when there's a new version.
- The company's privacy policy and terms are linked. okaydesigner.com's footer (home and changes) reads “© 2026 The Okay Company LLC · privacy · terms”, linking okaycompany.com/privacy and /terms. In the app, settings → about links both and carries the same line, and the account card says that signing in agrees to the terms and privacy policy.
- Migration: none.
- A box can get a stiffening frame, corner bumpers, or a screen moved in from the edge, as real geometry. Say “add a stiffening frame round the screen”: ribs under the top plate round the screen's keep-out (as wide as the plate is thick, at least 1.6 mm; as deep as the screen goes, at most twice the plate; inside corners rounded for a 3 mm cutter), cut back from the walls, the screw bosses and every other part. Say “add 5 mm bumpers”: TPU 95A pads on the top and bottom corners, wrapping the edge, proud of every face by their thickness, open round the parts, exported as bumpers.stl and listed in the BOM and spec sheet. Say “move the screen in from the edge”: as far as the layout allows without a clash.
- The FEA drop lands on bumpers. They aren't in the voxel model: they're a spring in front of the case, TPU pads stiffened for being thin (E·(1 + 2S²)), squeezed at most to half their thickness, sharing the blow's energy with the case in series. What's left once they're squeezed flat lands hard. Their push reaches the case under the squeezed part of each pad, spread through the pad, and their weight counts. The result says how far they squeezed and the force with and without them.
- A full FEA drop solves the worst six landings again, not two. With two, the desk focus timer's worst landing on the full model (a top edge, 0.6×) was third on the coarse ranking, and the check said 0.98×. Slower (up to a few minutes in the app), and honest.
- The autopilot changes the design itself when the full FEA still fails the drop, least change to the look first: the frame round the screen, the screen moved in from the edge, then 5 mm corner bumpers, each checked with the full FEA and kept only when it's better and the quick tests still pass. On the focus timer (PETG, 3.5 mm plate): 0.60× as it was; the frame 0.69× (kept); the screen 15 mm in 0.70× (not kept, no better); bumpers 0.97× (kept). It still falls short, and the need says why with the numbers: landing on a top corner, the 5 mm pads squeeze as far as they go and the floor still pushes back with about 2400 N (3400 N without them), and the case takes the rest. Thicker pads moved the worst landing to a flat one (8 mm: 1.39×); a machined aluminium case did worse (0.42×: on a rigid floor a stiffer case lands harder, and the model has no crushing to take the blow). Results near corners also change by up to a third between the full model and one twice as fine: the drop check can't be pushed to 1.5× for this design by any change the engines make.
- Migration: none.
enclosure.bumpers and topPlate.frame are optional; older designs open unchanged.
- FEA no longer judges a drop by the spot it lands on. Landing flat, the face that meets the floor is held to it, and two things there aren't the product: the outer layer of cubes is mostly empty (a face 0.2 mm into a 1.6 mm cube), so its strain read as several times the stress the material carries, and where a flat contact ends on a rounded corner the cubes make a step, which the model holds right up to its edge. A desk focus timer's full-FEA drop read 0.4× there, landing flat on its back, and pointed at thicker walls; the coarse check disagreed with it because of the same spot. Now a flat landing isn't judged within a cube of the floor or near where the contact ends on a rounding, as a landing on a corner or edge already wasn't (the limits said so for every landing; now it's true). The timer's real weak spot shows up instead, the same on the quick and the full model: the top plate beside the screen's cutout, landing on a top edge (0.98× on the full FEA, needs 1.5×), and thicker walls make it worse (heavier, it lands harder).
- The FEA drop says how it landed, and the autopilot says why it stopped. A result names its worst landing (
on its top back edge), and the edge of a flat box isn't called "flat on its right" any more. When the drop still falls short, the autopilot's need says where and how it landed, the fixes it tried with FEA and didn't keep (and why: worse, no better, or another test fails), where it stops (the plate and wall limits), and the changes it doesn't make that go at the weak spot: a frame or ribs round a cutout beside it, moving that part away from the edge, a rubber bumper on the edges and corners, a tougher material.
- Migration: none.
- The autopilot no longer piles plastic on to please a coarse FEA. Its quick drop check uses a few thousand cubes, about as thick as the walls, so it can point the way but not size a fix: on a desk focus timer it had thickened the top plate 3.5 → 5 → 7 mm for 0.8×, while the full check put the same plate at 0.33× and showed thicker walls helping most. Now a shortfall there tries a tougher plastic the build can make first (PLA → PETG), then a thicker plate or walls only within limits: a top plate up to 5 mm, walls up to 4 mm, and never past 1.5× what the design had (the AI's fixes are held to the same limits). Whatever is still short gets one full-detail FEA at the end (the build step's own check, about seven times the elements), and that's the result it reports, with its element count and cube size: a pass, or what's left to do in the build step's test panel. Only when the full check can't finish in time does the quick result stay a warning that asks you to run it.
- Phones, tablets and laptops get a drop fix too, and are tested in their own metal. A titanium or steel device was tested as aluminium; its frame is now tested in the metal it's made of. When the drop falls short, the autopilot tries a titanium frame (about two and a half times the blow for the same shape) and keeps it only when FEA agrees: a phone's full-FEA drop went from 0.5× to 1.05×, with the back glass now the weakest part. Any fix the FEA finds is also kept only when every quick test still passes on it, and the quick results it lists are for the design as it ends.
- A phone's "press it" presses the screen. The test pressed the thinnest panel it found, which on a phone was the black camera island printed under the glass (0.24 mm, failing with no fix). A layer laid on a thicker part (a print or mask under the glass, the display behind it) now counts as that part, and the panel has to be big enough for a fingertip (10 mm), so a SIM tray's edge isn't pressed either: the phone's screen glass is tested, and passes.
- A step that took just under three minutes said "2 min 60 s" on the checklist; it says "3 min 0 s".
- Migration: none.
- The autopilot: from an idea to launch. Type one idea and press autopilot to launch (describe or home). It runs every step with your AI team, and the engines check each one before the next: the design and its shape, the electronics and the circuit checks (with SPICE), the circuit board routed and checked, holding it together and the strength and drop tests (with an FEA drop on every face, edge and corner), the firmware run with its tests and built for the board, materials with the product's name on it and a photoreal render, the papers, and the cost. What fails gets fixed: the layout fixer, a better power path, another way to hold it together, the strength tests' remade-and-tested fixes, thicker walls or a tougher plastic checked with FEA again, then the AI, whose changes are kept only when the checks improve.
- A live checklist on the right of the model: each step's state and time, what the engines found with its label (*checked*, *estimate*, *proposal*), what it fixed and who did it. Pause, step in, change anything, resume: only the steps your change touched run again. Back to before any step; every step is a version. A change you make while a step runs is kept, and that step runs again on it.
- Works without an AI (the interpreter and the local engines), and better with one: designs from any idea, AI fixes, the program written for the idea (a proposal in the code chat, never committed for you) and the guide's introduction.
- The launch summary: verified, estimated, proposals to confirm, and what still needs a person: sourcing and quotes, confirming footprints and part numbers, trying it for real, a patent attorney, and the certifications that follow from what's inside (EMC or radio approval, cellular and SAR, IEC 62133 and UN 38.3 for lithium batteries, IEC 62368-1, RoHS, eyewear and toy standards). Download it as Markdown.
- A pocket synth template in the studio: each key plays a note of the scale through the speaker, the knob moves the octave, with its tests.
- Migration: none.
- A copy to the board can't leave it broken. Every file now goes over beside the old one (
name.new), is checked on the board by its size and CRC-32, and only when all of them are right are they swapped in, main.py last. A cable pulled halfway, or a byte that arrives wrong, leaves the old firmware as it was, and the next copy sends everything again. Files of an older build are removed only after the new ones are in.
- No flicker on the real screen. Okay BASIC on the board shows each frame once it's drawn (at FRAME, before each WAIT, and 30 times a second in a loop with neither) instead of okay.py's timer, which could show a frame half drawn, just after CLS. okay.py gains
auto_show(on); MicroPython programs keep the timer.
- Migration: none. A board copied to before gets the new okay.py the next time it runs.
- Plug in the board and one click runs it. In the studio, plug a Raspberry Pi Pico 2 into USB and press board (⌘⇧↩): it connects over Web Serial (Chrome, Edge, and the Mac app through Electron's serial support), builds the firmware, copies only the files that changed since the last time (a list of hashes on the board; sizes checked after every copy; files from an older build removed) and runs it. Uses MicroPython's raw REPL with raw-paste flow control, the way mpremote and Thonny do.
- The board in the studio. A bar over the device with run, stop, reset (main.py by itself, as at power-on), the REPL and copy all. What the board prints streams into the console (simulator or board, at its top right). Errors, MicroPython tracebacks and Okay BASIC's stops alike, open the file at the line, go to problems, and fix the board's error hands them, with what the board printed, to the AI, which answers with a diff as always. The board's screen and lights show beside the simulator's: okay.py reports them over USB when the studio runs it (
@okay: lines, at most five frames a second, never shown in the console; off when the board runs by itself). A REPL tab is MicroPython on the board, live.
- Hot reload on the board. With hot reload on, ⌘S (and applying an AI change) copies the changed files and runs the board again.
- No MicroPython yet? A Pico 2 without it shows up as a drive, not a board: the studio says so and walks through the UF2 install (download, hold BOOTSEL, drag the file onto the RP2350 drive, connect).
- Try it with nothing plugged in: try a pretend one is a pretend Pico 2 that speaks MicroPython's REPL byte for byte, copies files, runs Okay BASIC and reports its screen and lights. It's what the tests use too, and the tests also run every command the studio sends in real MicroPython (WebAssembly): okaybasic.py copied byte for byte, okay.py's reports, a real traceback mapped to its line.
- Migration: none. Firmware built before has no reports in okay.py; the studio copies the new okay.py the first time it runs a board.
- Real quotes. The build step's new quotes show what the product costs each at 1, 10, 100 and 1000 units, thing by thing (the circuit board, its parts, the enclosure, the rest) and in all. A supplier's own price is labelled quoted, with who, when and until when; everything else is the estimate, and a total is quoted only when every line of it is. This is the first use of the
quoted label.
- The circuit board from OSH Park's prices: bare boards priced from OSH Park's published list (three copies a set, or a medium run when that's cheaper), shipping included, no account needed. Where the estimate for JLCPCB- or PCBWay-class houses is lower, it shows underneath.
- The board's parts from DigiKey and Mouser, with your own keys: every part with a maker's part number (choose real parts with find parts) priced at each quantity, with the supplier's minimum, multiple and stock. Paste your free keys under supplier keys; they stay on this computer and go only to that supplier. A quoted part replaces its library price; the rest stays at the estimate.
- Never orders or pays: every supplier has open the order page on its own site, with the file to upload beside it (board-fab.zip, body.step, top-plate.step). JLCPCB, PCBWay, LCSC, Xometry, SendCutSend and Craftcloud give no quote without an order or a partner account, so they say so and show the estimate.
- Migration: none. Your keys, if you add them, are kept apart from your AI keys and never go to your account.
- Ideas in the new product box. surprise me (or ⌥R) writes a random product idea into the box, typed in front of you: what it does, its size, what it's made of, how many and for how much. While the box is empty it shows a different idea every few seconds, and Tab takes the one showing. The chips under it are random ideas too: hover one to read the whole idea, click it to use it, and more ideas deals a new hand.
- A checklist as you type. Under the box, the five things a good description says (what it does, how big, made of, how many, for how much) light up as you write them. Click one that's missing and a sentence for it is added; with all five, design it glows.
- Remix in one click. Once there's a description: smaller, more premium, cheaper, 10× the units, waterproof, add a screen, battery powered, for kids. Sizes, prices and quantities already written are changed in place (smaller takes a quarter off every dimension, cheaper 30% off the price); ⌘Z undoes any of it in one step. The same box is on home and on the describe step.
- A product's name stops before what it does: "a calm phone that lasts two days" is named calm phone.
- Okay BASIC runs on the real board. The studio's one-click build now makes firmware for BASIC products too: main.bas,
okaybasic.py (the Okay BASIC interpreter, ported to MicroPython: the same language, the same colours, the same friendly errors) and a main.py that starts it, on the okay module made for the product's pins. Copy the folder onto a Pico 2 with MicroPython and it runs as in the simulator. PRINT goes to the USB serial console; an error stops the program and shows its line and message on the screen and the console. The build's warning, and the button that asked the AI to port BASIC to MicroPython, are gone.
- Tested against the simulator's interpreter. The Node tests run okaybasic.py in MicroPython (WebAssembly) beside the simulator's BASIC on the same programs and inputs: every BASIC template passes its own tests on it, and every drawing call, light, sound, brightness change and line printed matches, call for call; so do the rest of the language, the runtime errors and the compile errors. Then the built main.py runs main.bas on the real okay.py.
- A second
ELSE (or an ELSEIF after the ELSE) in an IF block is now a friendly error instead of a crash.
- Migration: none. Firmware built before had main.bas alone; build again.
- The top bar fits any window. On a laptop-sized window (1024 px) the bar ran past the edge and the whole app scrolled sideways. Now the steps make room first: closer together, then without their numbers (and the name beside the logo, and the library button's word, give way to their icons), then scrolling inside the bar with the step you're on always in view. On a phone, "connect an AI" says AI and basic/advanced is one button naming the mode it switches to.
- The library is a window. Press library at the top right on any step (or open the library on home) and it opens over what you're doing, like SketchUp's 3D Warehouse: one search across templates, modules and the community, the kinds down the side with how many match, and the results as a grid. Using a template or a module closes it and puts you straight into the design; Esc or a click outside closes it too. Publishing one of your products opens it there. Home keeps a short strip of templates that opens it.
- Find parts stays where you are. Choosing a part, taking it back, making, confirming or removing a footprint lays the board out again, and the page now comes back to the part or footprint you were working on instead of the top.
- A footprint you made is offered only for parts it really fits: the same number of pins, and for anything but a resistor, capacitor or LED the same mounting (a 1206 isn't offered for a key switch).
- Find parts. Every part on the circuit board can be a real one: find parts searches LCSC, DigiKey and Mouser together and shows each match's stock, price breaks, datasheet and LCSC number. Use this sets the part's value, its footprint (for standard packages: 0402 to 1206, SOD, SOT-23, SOIC, TSSOP, MSOP, QFN, DIP) and its LCSC number on the board, and the BOM, placement and KiCad files follow. An LCSC number only ever comes from LCSC: a part from DigiKey or Mouser has none. The suppliers' keys live on okaydesigner.com as secrets and never reach the app; search goes live as each supplier's keys are set.
- Footprints from datasheets. Paste a datasheet's package pages or open its PDF: the AI reads the land pattern's numbers and the engine builds the pads and checks them (pads against pins, the pitch against the datasheet's and the finest the board house makes, gaps between pads, copper rings round holes, the courtyard round every pad and the body, pin 1, a centred origin). Or type a standard package name. Each one is drawn with its checks and stays a proposal until you confirm it; confirmed ones can go on any part whose pins they have.
- The ERC says when a part you chose no longer fits its place (the product changed, or its footprint hasn't the pins the board wires).
- Circuit simulation in SPICE. The electronics step runs the product's circuit in ngspice (the open-source SPICE, compiled to WebAssembly, on your computer) every time the electronics change: the board's LEDs, resistors, decoupling and knobs on their nets, with models of the battery and its internal resistance (or USB and its cable), every regulator (LDO dropout, buck, boost and buck-boost efficiency, soft start) and every part's current. Operating point: each rail's voltage under peak load and each LED's current. Start-up: the rails coming up, then how far they sag when everything that sleeps wakes at once. Battery or USB sweep: where each regulator drops out. Rail impedance: each rail's stiffness from 10 Hz to 100 MHz. Ripple: each switching regulator's power stage, switching. A waveform viewer reads every series at the pointer; the netlists download for any SPICE. Checks from it are labelled estimate, never measured; tested against hand calculations (RC step, divider, RC corner, LED current, LDO dropout, buck and boost ripple).
- Edit the circuit board by hand. On Papers → circuit board, drag a part the placer put (the controller module, a resistor, a capacitor, a header off the top plate) and press R to turn it; parts under a key, knob or light follow their feature on the top plate. Click a track to delete it (an autorouted one: its net is then yours to route), lock the net (L) so its copper stays as it is, or re-route the net. Route a track by hand (X): click a pad, click corners (straight runs and 45° bends, / swaps the bend), V changes layer with a via, and a click on a pad or track of the same net finishes it; Enter leaves the rest for the router. Autoroute the rest hands the nets you left back to the router, and clear my board edits goes back to the board as the engines lay it out. ⌘ or Ctrl and the wheel zoom.
- The router works around you. Your tracks and vias go down first, marked in the router's grid like any copper: it routes around them and only connects what they don't, growing each net through your copper. After every edit the board is laid out, routed and checked again (ERC and DRC on the finished copper), so the checks always describe the board as it now is; your parts and tracks show dashed.
- Your edits stay with the design (
Design.board): undo, versions, saving, the AI changing the product and re-layouts all keep them. A part's edit is kept by what it's for (its feature), so adding a part elsewhere doesn't move it; tracks on a net the board no longer has are left out, and the DRC says how many.
- Migration: none.
Design.board is optional; a design without it lays out exactly as before.
- The studio: a full-screen place just for programming. Open it from the program step, or from home (just programming), where a dev kit (a screen, two keys, a knob, a light and a speaker) is one click away. Files in a tree, tabs, and a real code editor (CodeMirror 6): colours for Okay BASIC, MicroPython, JSON, Markdown and tests, completions, brackets, folding, several cursors, find and replace, quick open (⌘P), and problems underlined as you type with a problems list.
- The device runs beside the code. The 3D model, a big pixel-for-pixel copy of its screen, and its keys, knobs and lights as buttons. Run (⌘↩), stop (⌘.), and hot reload: the program restarts a moment after you stop typing, once it has no errors.
- Device tests. Write them in plain steps in
tests/*.test (press key 1, turn knob 1 by 5, wait 2 s, expect screen shows "25:00", expect light 1 is orange, expect no error). Okay BASIC and the interface run them in virtual time (ten minutes of the device's time in a moment); MicroPython runs them on the simulator. Failures say what the screen showed instead and point at the line.
- History with branches. Commit, discard, revert, and now branches: start one, switch, and merge (a three-way merge, line by line; conflicts marked the way git marks them), shown as a diff you apply. A terminal with git's words (
git status, git diff, git log, git checkout -b, git merge, git commit -m), plus ls, cat, grep, run, test and build. Export the repo with its history as patches for git am.
- The AI engineer, end to end. It plans first (you see the steps), changes as many files as it needs, runs the program on the device while you watch, runs the tests and fixes what fails, and knows the open file, your selection (⌘K) and the problems. Every change is a diff: apply it file by file, reject it, or try it on the device first. One click asks it to fix the device's error, the problems or the failing tests, to write tests, or to port Okay BASIC to MicroPython.
- App templates with their tests: a focus timer, a counter, a settings menu, a catch game, a clock, a macro pad, a blinking light, a MicroPython dashboard in two files, and a reaction game. Starting from one is a commit, on a new branch if you like.
- A screen designer that round-trips to code. In Okay BASIC and MicroPython a screen is a block of drawing code (
' @ui home … ' @end, drawn with GOSUB ui_home or ui_home()): drag text, values, bars, boxes, circles, lines, a clock and the battery, and the code changes; change the code, and the designer follows. Lines it doesn't understand stay where they were.
- Firmware in one click. build makes a zip for a Raspberry Pi Pico 2 with MicroPython: your files, an
okay module made for the product's pins (the same pins as the schematic and the circuit board: keys with press counts, knobs, lights, the speaker, SSD1306 and SH1106 screens), a manifest and how to copy it on, with the build's checks. An interface becomes a main.py. Okay BASIC has no runtime on the board yet, and the build says so.
- The circuit board, designed from the product. Papers → circuit board lays out, routes and checks a real two-layer board for any enclosure product, in the background in a few seconds. The outline is the enclosure's inside, cut around the corner bosses; every key, knob, light, screen header and potentiometer sits exactly where it is on the top plate; the controller module (Pico 2 pinout for the RP2350, XIAO for the nRF52840 and ESP32-S3) goes where its USB end meets the USB-C cutout, or the nearest place it fits; resistors and capacitors go beside what they serve. Pins come from the firmware's pin map, so the board, the schematic and code.py agree.
- Autorouter. A two-layer maze router (45° tracks, vias, rip-up and retry) connects every net, then floods the bottom with ground and removes islands.
- ERC and DRC, checked on the finished copper. Electrical rules: every pin connected, every supply driven once, no shorts, enough controller pins, the module's USB within reach of its cutout, what isn't on the board. Design rules, measured by an engine that doesn't trust the router: clearance between every pair of copper shapes, copper to the edge and holes, drills and annular rings, overlapping parts, and every net proved connected by tracing its copper.
- Board files. One zip for JLCPCB (Gerber X2 for copper, mask, paste, silkscreen with references and the outline; Excellon drills, plated and unplated apart; a Gerber job file; BOM and placement in JLCPCB's assembly format), a KiCad board (.kicad_pcb with the ground zone) to keep working in KiCad, and a picture of the board. Also in the build step's production files.
- The schematic's LED resistor is now the E24 value the board uses (270 Ω).
- Change the papers in the chat. The chat now stays on the papers step. Ask it to change the papers themselves: “add a section Warranty: two years”, “remove the safety section”, “rewrite the care section: …”, “in the patent, remove the background section”, “add a note: anodise black, type II”, “change the summary to: …”, “rename it to …”. With an AI connected, ask for anything (“make the guide friendlier”, “claim the magnetic hinge in the patent”): it rewrites sections of the user guide, patent draft and spec sheet, adds notes to the drawings, or, when you're really asking for a change to the product, hands it to the engineer and every paper follows the new design.
- Your edits stay with the design. They're saved in the design, so versions, undo, downloads and your account carry them. Each paper lists your edits to it, and × takes one back. The rest of every paper keeps following the design: change the product and the sizes, parts and claims update around your words.
- Fixed: the chat no longer falls apart while the AI works. The loading overlay's styles also matched the busy chat, blurring the view behind it and turning every word in the chat ("reading the code", "now", the AI's name) into a spinning circle.
- Fixed: the left panel folds away in the program step too (the program step's wider panel ignored the fold button).
- Photoreal renders. The See it step's render photoreal traces light through the scene (path tracing, three-gpu-pathtracer 0.0.26): real reflections in metal, light passing through tinted or frosted glass, soft shadows on a seamless floor and depth of field with a real f-stop. Choose a white studio, warm paper or a dark studio and a quality; the picture cleans up as samples add up, pause any time, and download PNG. Resizing the window restarts the picture at the new size.
- Real materials. Click a part (or a box's body or top plate) and pick its look from 34 materials: bead-blasted and anodised aluminium, brushed and knurled metal, steel, titanium, brass, gold PVD, gloss and soft-touch plastics, acetate and tortoiseshell, clear and tinted glass, leather, rubber, silicone, fabric, walnut, oak and ceramic. Each has its own texture (bead blast, brushing, knurls, grain, weave, wood, speckle) in the 3D view and the render. Invent a material sets colour, shine, roughness, transparency, sheen and texture, kept inside what's physically possible.
- Labels, icons, images, stickers and engravings. Add one, click where it goes and it wraps onto the surface; drag it to slide it, and edit its text, size, turn, colour and style (printed, engraved, embossed, sticker) in the inspector. They show in the layers panel, come apart with the exploded view and are saved with the design.
- In the chat: "brushed aluminium body", "walnut top plate", "tortoise frame", "frosted lenses", "add a label 'TIMER'", "engrave the text 'OK'", "remove the labels". The AI keeps the look and the labels when it rewrites a design.
- Fixed: choosing a part in the layers panel now opens its inspector.
- Sliders change the model live. Dragging a slider (the glasses' sizes, a box's size) reshapes the model while you drag instead of after you stop: it used to wait until you paused, then take two to three seconds per change. While a slider moves the kernel builds a quick draft (no rounded edges, no holes cut, a coarser mesh, about 0.05–0.2 s for glasses) and always works on the newest position; when you let go it builds the full model. The kernel keeps solids it has already built, so a change rebuilds only the parts it touches.
- Photos with real people are easy to set up. Instead of “add your Google AI key in settings”, the See it step shows two steps in place: open Google AI Studio to create a key, then paste it (a paste button reads the clipboard). The key is checked with Google as you paste it, with a plain answer when it's someone else's key (“that's an Anthropic key”) or isn't valid; pressing make the photo first waits for the key and starts the photo once it works. A Google Gemini key connected as your AI makes photos too, with nothing more to set up.
- Check with FEA. Under any test, check with FEA runs it again with finite elements on a voxel model of the real solids (about 24 000 cubes, 8-node elements that bend properly even one or two cubes thick, solved in the app in seconds to a minute, with progress as it goes). It finds what beam theory can't: the stress gathering at holes, hinges and inside corners; drops landing on every face, corner and edge (all 26 for a box, the worst two solved in full); drops of any free form, such as a phone, which the quick test couldn't do. The result says “FEA, N elements”, where it's worst (“the top plate, beside the key 1”), how hard the floor pushes back, and paints the model (switch between the quick estimate's colours and FEA's). Still an estimate: linear-elastic, one vibration mode for an impact, curved surfaces in steps of one cube. Checked against the textbook: a cantilever's deflection to 0.1%, a plate, and the stress at a hole (Kt 3.15, as Peterson's charts give).
- A phone's, tablet's or laptop's own screen runs your program. Power it on in the program step and the display itself lights up on the model with what the device draws: the interface you design, Okay BASIC, MicroPython or Linux. The screen has the panel's real proportions (a 14-inch laptop is 1280 × 832, a phone portrait), so the interface is laid out for it, and it stays on the display when the parts come apart.
- Explode it your way. With exploded ticked: apart spreads the parts up to four times further; drag any solid (the display out of the lid, the plate off the case) to put it where you want, ⌥ for 0.1 mm; a plain click still selects it and dragging empty space still turns the view. Add note, then click a spot on any part, and type: the note is pinned there with a leader line and rides with the part as it moves; edit it in place, × removes it. Reset puts the parts back. The arrangement and notes are saved with the design, undo with ⌘Z, and survive changes from the AI.
- The okay model joins the AI team. A new card, “okay model (your own)”: your private model from okaydeploy. Paste an
okm_ key for the cloud, or the address of an okay model on your own server (https://your-server:8484/v1) or this Mac (http://localhost:8484/v1, no key needed). Pasting an okm_ key or a :8484 address anywhere finds the card. It ranks third for code and after the frontier models for everything else; choose it under “who does what” to keep a job private.
- The web app may now reach okaydeploy (
okaydeploy.acificlabs.workers.dev, okaydeploy.com), an okay model on this computer (localhost:8484) and on-prem okay models over HTTPS on port 8484 (CSP connect-src in site/public/_headers).
- Tested against a running okay model (test/okaymodel.test.ts, with
OKAY_MODEL_URL): a forced tool, and the JSON-in-text fallback for servers that refuse tools.
- "Failed to fetch" says what to do. When a local model (Ollama) can't be reached, the app says how to start it so the app can reach it (
OLLAMA_ORIGINS="*" ollama serve, pull the model, allow local network access in the browser); for other providers it points at the connection or the address. Your team still hands the job to another AI meanwhile.
- The best model is picked for you. Paste a key and the app reads the models that key can use from the provider (for Gemini, from Google's own list of models that can generate, without embedding, voice or image models), ranks them (newest first, then pro / opus over flash / mini / haiku) and picks the best, marked “· best”. Switch any time, in the form or later on your team.
- A model that isn't available for your key (not found, not allowed, retired) no longer stops the connection: it connects on the best model the key does have, and says so.
- Claude keys made for a whole organisation work. Anthropic answered “This API key is not scoped to a workspace”. Now the app explains it in plain words and offers two ways: make the key inside a workspace, or paste the workspace ID (wrkspc_…) in the box that appears, which is sent with every request.
- Your AI team. Connect as many AIs as you like (Claude, GPT, Gemini, OpenRouter, Groq, Grok, a local model). Each job goes to the best one you've connected: designing, changes, code and reading parts to Claude first, ideas to Gemini first; or choose who does what. If one is busy, out of credit or down, the next one takes over by itself. The menu shows your team (each one's model and what it's doing, remove), who does what, and the providers you can add.
- Models come from the provider. Once your key is in, the model list is the one the provider gives for that key, so new and retired models are always right. If a model has been retired (Gemini 2.5 Pro for new users), connecting switches to the replacement the provider names and says so.
- Every provider connects, whatever its quirks: models that refuse a forced tool (the newest Claude, Groq) and models with no tools at all (many local ones) are asked the next way automatically, and the app remembers.
- The web app's page is never served stale: okaydesigner.com/app checks for a new version on every load (its files were already versioned).
- The key box starts empty for each provider: a key typed for one never shows up under another, and saved keys are never shown back.
- Every product has a repository. Its software is a set of files saved with the design:
main.bas (Okay BASIC), main.py (MicroPython), screens.json (the interface designer's screens), README.md, and any file you or the AI add. The device runs the entry file for the software you pick. Designs from before move their program and screens into files the first time you open them.
- A real editor in step 05: the files, tabs, colours for BASIC, Python, JSON and Markdown, line numbers with the error's line marked, Tab indents. Your edits show as changed until you commit them (⌘S, with an optional message) or discard them.
- History: every commit, with its message, who made it (you or the AI), when, and its diff. Open one to see what changed; revert undoes it with a new commit.
- The code chat writes the software. On step 05 the chat under the model is a code chat: ask “make the knob change the screen brightness and show a battery icon” and the connected AI reads the files, writes them, runs them on the simulated device and reads its console, fixes what broke, then shows you the change as a diff. Apply makes it a commit, reject drops it, try it on the device runs it without applying. When the device stops with an error, the chat offers ask the AI to fix it, and the console goes along with every request. Without an AI it says what it needs (any key, kept on this computer, sent only to its provider).
- BRIGHTNESS in Okay BASIC and
brightness() in MicroPython set a screen's backlight, 0–100, and the screen on the model dims.
- MicroPython programs can import the repo's other
.py files.
- Opening the app straight into the program step (
?tab=program) starts the device's loop, so power and run work.
- Real, adjustable phones, foldables, tablets and laptops, with everything inside. “Design a phone”, “design a foldable phone”, “design a tablet” or “design a laptop with 5G” builds the product the way it's really made: a frame and midframe (or an aluminium unibody, or a laptop's top case and bottom case), glass front and back, the display and its black border behind the glass, a camera bump with lens rings, lens stacks and sapphire covers, a flash, real side buttons standing in their holes, the USB-C port, speaker and mic grilles, an earpiece slit, a SIM tray and antenna lines in a metal band. A laptop has a keyboard of 78 keycaps in its well, a glass trackpad, feet, a hinge and a lid that opens to any angle with the webcam in its border or a notch. A foldable is two halves on a hinge: one screen across both inside, a cover screen and camera outside; fold it shut, half open, or flat.
- Every size follows the screen: its diagonal, its proportions and the border round it; then thickness, corners, the frame band, the bump's height, the hinge or the lid. Choose the material (aluminium, titanium, steel, plastic, magnesium), flat or rounded sides, one to four cameras in a square, a column, a bar or a circle, a punch hole, island or notch, 5G (with mmWave) or Wi-Fi only, a SIM tray or eSIM, speakers, USB-C ports and an action button. Each change remakes it as real solids and keeps what you did by hand.
- The insides are bays you can see: the logic board (standing up in a phone), the battery (two cells in a foldable, three in series in a laptop), the camera modules, the speakers and haptics, the fan, the SIM reader, the 5G modem and the antennas in the frame bands or the hinge. The battery is as big as its bays allow, so a thinner phone holds less.
- The electronics follow the design: the system-on-chip, each display's power from its area, the 5G modem and mmWave modules when you ask for them, Wi-Fi 7, GPS, NFC, the hinge sensor, the keyboard light, trackpad and fan; cameras, mics, speakers and the flash come from the parts on the form. Battery life, charging and the papers follow, and the power plan suggests a battery with USB-C.
- Ask in the chat: “thinner”, “bigger screen”, “thinner bezels”, “three cameras”, “camera bar”, “titanium”, “make it blue”, “fold it” (a bar phone becomes a foldable; a foldable folds shut, “unfold it” opens it), “close the lid”, “add 5G”, “four USB-C ports”, “bigger trackpad”, “like an iPhone”, “like a Pixel”, “like an iPad”, “like a MacBook Air”: proportions only, as numbers; no names or marks go into the geometry. With an AI connected it changes them through their parameters (change_phone, change_tablet, change_laptop), checked against each range.
- With an AI connected, a laptop, phone, tablet or pair of glasses is still the real model. “Generate a MacBook Pro” used to go to the AI, which could write a rough form of its own (a laptop as two boxes, shown over the last product with an error). Now the engines build the parametric model and the AI tunes its parameters to your words. A laptop, phone or tablet the AI sketched as a few boxes becomes the real model when you open it.
- You can see it working. While it designs, a card shows each stage, a tick on the ones done and a timer on the one running (“reading your words”, “xAI is designing it”, “building the solids”), with a note that an AI design takes 20 to 60 seconds. The button says “designing…”, and a build that takes a moment says “building the solids…” over the model.
- A screen simulator or parts list that hits a problem no longer stops the 3D model from building.
- Names come from “generate a…” and “draw a…” prompts too (“generate a macbook pro” is called “macbook pro”, not “laptop”).
- The 3D view frames a new product afresh (it kept the last product's distance, so a laptop after a phone showed only grey).
- Glass takes its colour as a tint when it has one: a phone's back glass shows its colour, clear lenses look clear.
- The shape language has a group (separate solids kept together without joining them, like keys or buttons), and a form can have up to 12 bays.
- Migration: none. Phones made before this keep their old single-slab form (without controls); design one again for the new model.
- Test it: strength tests on the real solids. The build step has a test it panel: drop it from 1 m, sit on it, twist it, press the screen, and for glasses put them on (how far each temple can spread before it stays bent) and press a lens. Each test runs on the meshes of the actual B-rep solids: sections are cut from them every few millimetres, thicknesses are measured by rays through them, mass and inertia come from their volume. You get a pass or fail with a safety factor (1.5× asked of things that bend, 2.5× of glass), where it's worst, the forces in words, the method, and what it doesn't cover. Every result is an estimate (beam and plate theory, not FEA), and says so.
- Stress colours on the model: blue where it's idle through green and yellow to red where it reaches its limit; parts the test doesn't load stay grey.
- Fixes that are tested before you see them. When a test fails, the app proposes changes in words (“make the temples nylon”, “make the top plate 3.5 mm thick”), remakes each one, runs the test again and shows only those that help, with the safety factor they reach. apply sends it through the chat like any other change (one undo step, one version), and the test runs again on the new solids. With an AI connected, ask the AI for a fix.
- Materials: PLA, PETG, nylon (PA12 / TR90-type), ABS/PC, polycarbonate, cellulose acetate, aluminium 6061-T6, titanium Gr5, stainless steel 304, glass, strengthened (Gorilla-type) glass and TPU, each with density, stiffness, yield and breaking strength, Poisson's ratio and a fatigue note. Choose one per part in the panel or in the chat (“titanium temples”, “polycarbonate lenses”, “make the walls 3 mm thick”). Invent a material: give its numbers and it's checked against what physics allows (nothing denser than osmium, stiffer than diamond, or stronger than about a tenth of its own stiffness).
- Air resistance, a first pass: the area the solids show the wind and a drag coefficient from their shape (Hoerner's wind-tunnel data), the drag force and the power to push it, at a speed and heading you choose. An estimate, not CFD.
- The chat understands thicknesses: “temples 5 mm thick”, “front 7 mm deep”, “rim 5 mm”, “walls 3 mm”, “top plate 3.5 mm”. “Make it PETG” now changes the top plate too when it was the same material as the body.
- Clicking a solid selects it. On glasses, phones, laptops and other free forms, clicking a temple, the frame, the lid or the base selects that part (it lights up and its inspector opens) instead of “the enclosure”. Clicking empty space clears it.
- Connecting Claude works with the newest models. They don't accept a forced tool choice and answered “tool_choice … not supported for this model”; the app now retries with the tool offered and remembers that model.
- The key goes in its step. Pick a provider and paste the key in step 2, right under “get a key”, with a note saying whether it looks like that provider's key (or which card to pick instead). Without a provider picked, a box below the cards finds it from the key.
- Connect an AI, like a marketplace. Every provider is a card: what it's best at, what it costs, and which have free tiers (Google Gemini, Groq, OpenRouter's free models, a model on your own computer) or are recommended (Claude). Pick one and follow three steps: get a key (a button opens the exact page, with how to make the key), paste it (it checks it looks right), pick a model from a list (or type any model and address under "another model or address"). Esc closes it.
- Your account, top right. An account icon (your initial when signed in) opens a menu: who you are, your products, settings, the AI, what's new, the Mac app, manage OkayLogin, sign in or out. Settings (account, company, AI engines, enterprise licence, about) open in a sheet over whatever you're doing, instead of at the bottom of home; Esc closes it.
- The chat does what you ask more often: it reads typos (“more liek raybans”, “smaler camra”), and glasses designed before 0.11 become fully adjustable the first time you open them or ask for a change, keeping their colours, with their parts replaced rather than doubled.
- Connecting xAI: a Grok agent key (grok_…, made for Cursor on grok.com) now gets a plain answer: the API needs an xAI API key from console.x.ai (xai-…). A Claude sign-in token gets the same kind of answer.
- The button that folds the left panel away sits at the panel's top right (it covered the step's label); folded, it waits at the 3D view's top left.
- Ask for any change, on every step. A chat sits under the model: “more like Ray-Bans”, “smaller camera”, “no speakers”, “invent a new idea for speakers”, “10 mm taller”, “add a knob”, “make it white”. It changes the design you have (it used to start the whole design over from your first prompt when no AI was connected), says what it did, and gives each change an undo this. With an AI connected it understands anything; without one, sizes, styles, parts, colours and finishes work on this computer.
- Versions: every change from the chat, the controls or a drag is a version; open the history (the clock, or H) and restore any of them.
- Real, adjustable glasses. Seven frame styles (wayfarer, round, oval, rectangle, square, aviator, cat-eye) drawn as real lens shapes, a brow bridge, nose pads, hinge blocks, and temples that hold the electronics in slim pods, taper to the ear and bend behind it. Sliders for every size; choose open-ear or bone-conduction speakers or none, the camera's place and size (a new 4.6 mm mini camera), mics, magnetic or USB-C charging, the privacy light and the capture button (a new capsule button). Speakers are slot grilles in the temples now, not discs. Changing a size keeps what you did by hand.
- The inspector: select any part for what it is (hole, room, depth, cost), rename it, swap it, set its exact position and direction, source it (Alibaba, AliExpress, LCSC, Digi-Key, Mouser) or ask the AI to redesign it. Select a solid of the form for its size, finish and colour, download it alone as STEP or STL, with links to manufacturers for a quote.
- Drag parts over a free form: select a part on the glasses and drag it; it slides over the surface and faces the way the surface does.
- Exploded view for free forms: the parts move apart, the lenses out of the frame.
- Fold the panels away: the left panel (its button, or [) and the parts palette (click its title).
- Ports and grilles on free forms are cut only as deep as the part needs.
- The selection bar lands where you let go. Dropping it jumped by the distance between the pointer and the bar's centre, and anywhere in the bottom 110 px snapped it to the dock. It now stays exactly where it's dropped (held by its left edge, so buttons appearing don't shift it), and docks only when dropped right at the top edge or onto the tool dock, centred over it.
- Free-form products stand on the floor. Glasses and other free forms were built around their centre, so half of them sat under the grid; they now rest on it, in every scene.
- Hold space and drag to pan the 3D view, like a design tool (right-drag still works too).
- Layers (L, or the stacked icon in the dock): a panel with every solid (the body and top plate, or each part of a free form) and every part on it. Click one to select it (a free form's part lights up), the eye hides it, the lock stops it being picked or dragged. The inside has a row too.
- It designs things that aren't boxes. Ask for smart glasses and you get glasses: a front frame with nose pads, two temples with hinges and ear hooks, and lenses, the camera and light in the frame, mics underneath, speakers in the temples near the ears, the touch button and charging pins on the temple, the board and battery in bays inside the temples. A phone, a watch, an earbud case, a lamp and a game controller have shapes of their own too.
- The AI writes the shape. With an AI connected, any product gets a form written in a small shape language: boxes, cylinders, spheres, extruded and revolved outlines, lofts, unions and cuts, shells, fillets, moves and mirrors, in named parts with finishes (plastic, metal, rubber, glass, fabric). The engines build every part as a real solid, cut each mounted part into the surface, check the board and battery fit their bays and that there's a way to power it.
- In the design step, the form lists the parts: change each one's colour and finish. Every part exports as its own STEP and STL, with the whole assembly as one STEP. The drawings show the main part and the assembly.
- Drawings fixed: the front and side views were drawn upside down, and a part that wasn't centred could sit off the sheet.
- A real schematic (papers → schematic): an A3 sheet drawn from the electrical model and the pin map. The way in (USB-C with its CC resistors and data lines, a magnetic or Qi input, a DC jack), the charger, the cell with its protection, every regulator with its capacitors and rail, the controller with each pin it uses, and every part with an IEC symbol: switches to ground with the controller's pull-ups, encoders, LEDs with the resistor worked out for 5 mA, displays on SPI or I²C (with pull-ups), potentiometers and joysticks on the ADC, the speaker amplifier. Parts join the controller by matching net labels; a grid frame and a title block finish it. Download as SVG.
- The spec sheet as a product page: the name big and lowercase, the product rendered on paper, dimensioned top and side views to scale, and the numbers in mono on a quiet grid (size and estimated weight, materials and closure, controls, display, power and battery life, connections, the inside, software), with the fine print. Print it or save it as PDF; the text version is still there.
- The papers use the whole window.
- Connect any AI. Press connect an AI (top right) and paste any key: it works out whose it is (Anthropic, OpenAI, Google Gemini, OpenRouter, Groq, xAI) or point it at a local model (Ollama). Pick the model, test the connection, done. Designing, changes, ideas and reading specs all use whichever one is connected; reading a link needs Claude's web fetch. Keys stay on this computer and go only to their provider; the web app's security policy allows exactly these providers.
- How it holds together (design step): screws into inserts, magnets in pockets (choose size and count), glue on the rim, snap-fits (hooks under the plate that click into windows in the walls) or a press-fit lip, each built as real geometry. A hold test works out what it needs to survive (lifting it by the top, a 1 m drop, every key pressed hard) against what it holds, checks snap hooks' strain against the plastic's limit (PLA cracks, PETG flexes), and says when it can never be opened again (no repairs, no new cells). Make it hold picks a stronger setup.
- The okay company boots every product. Powering on shows the okay company's mark, like a phone's maker logo. Only an enterprise licence unlocks a custom boot screen: the master admin issues licences with
scripts/issue-license.mjs (signed with a private key that never leaves the admin's computer); the app checks them offline, so they can't be forged or edited. Add one under settings on home.
- Parts of your own. Open more in the parts palette and choose a part of your own: any screen (any diagonal, any resolution, colour, OLED or e-paper, round, touch: the window, module, power and price follow from the panel), from specs (paste a product link from Alibaba, AliExpress, Digi-Key, Mouser or a maker, or the datasheet's text: the AI reads it with your Anthropic key, and pasted text is read on this computer without one; check the numbers, then add it) or by hand (the hole, the room it needs, depth, faces, price, voltage, current, pins). Custom parts travel with the design and its modules, cut real geometry, draw power, appear in the drawings and the bill of materials, and work in the simulator.
- Basic and advanced (top right): basic shows what matters (shape, size, materials, parts, power, the inside); advanced shows every number: walls, radii, plate thickness, exact positions and turns for every part, rails, components and firmware pins.
- A new part that doesn't fit makes room: the body grows, like a module.
- Power, chosen with advice: the electronics step opens with every way to power the product, worked out for this design: USB-C power, a battery with USB-C charging, a battery with a magnetic 2-pin charging connector, a battery with wireless (Qi) charging, 2 × AA, 3 × AAA, a coin cell (CR2032) or a DC adapter. Each shows battery life or "while plugged in", charge time, what's good, what to watch and the cost a unit, and the one that suits how it's used is suggested with why. One click switches: the input, battery and charger, how the rails are fed (boost, buck or buck-boost from the cells), and the part on the wall (USB-C, the new magnetic connector, a barrel jack, or nothing for wireless and cells). Inside, AA/AAA holders, the coin cell holder and the Qi coil appear at their real sizes; cells are replaced, not charged.
- The selection bar can be dragged anywhere by its grip, docked at the bottom or top (it remembers), closed with ×, and brought back by double-clicking a part or the body. It never runs off the edge.
- A screen you add now shows on the model. The simulator compared the design with itself after an edit, so a newly added (or swapped) screen was never created and stayed black. It now notices every added, removed or moved part.
- A screen added to a product that had none gets a starter interface; a starter program that never drew anything switches to it.
- The library, on home: templates to start from (macro pad, game controller, focus timer, smart speaker, weather station, pocket synth, presentation remote, mini Linux terminal), modules to drop into any design (row of keys, numpad, navigation cluster, screen with buttons, knob and light, game pad, fader bank, power and charging, speaker and mic) and the community: publish any of your products as a template or as a module (title, description, tags, licence), search what others published, and use it in one click. A module finds room for all its parts at once and grows the body when there isn't any; the fixer then makes sure everything still passes. Selling (a price, paid downloads to print yourself) comes next.
- Designs made from words are now left valid: the interpreter runs the fixer, so a battery always has room.
- Migration:
0003_library.sql (the community library), applied.
- The Mac app opens again. 0.5.0 and earlier were unsigned, which macOS on Apple silicon reports as "damaged". The app is now signed ad hoc and its seal is verified at build time: the first time, macOS asks you to confirm it (System Settings → Privacy & Security → Open Anyway). A Developer ID signature comes with the Apple developer account.
- Updates: the Mac app checks okaydesigner.com for a newer version and shows update with what's new. okaydesigner.com/changes lists every version with its changes and a download for each (
/download/mac/<version>). npm run release uploads, writes the page and deploys in one step.
- The inside, in the electronics step and with inside (I) in the dock: the body turns to glass and shows the main board under the parts it carries (with its controller underneath), the battery sized from its capacity, display and speaker modules, ports on the walls, brass standoffs, routed wires from everything that isn't on the board, a TPU gasket in the top rim (cut into the body and exported as gasket.stl) and rubber feet. Move the board and battery; a new check says when something doesn't fit, and by how much. The battery, wires, gasket and feet are in the bill of materials.
- Make it better (✦ improve, or B): fix the problems (clashes, parts off their face, too thin for the battery, walls, the MX plate), tidy the layout (rows and columns, even gaps, centred), fit snugly (the smallest body around the parts), and ideas that apply in one click (add a screen or a power switch, double the battery, seal it, make it a pill…). With your Anthropic key, ask the AI for its own ideas and apply any of them. Every change is listed, with undo.
0.5.0
2026-10-18download .dmgunsigned build: macOS may refuse it; use 0.26.1- Program it (new step 05): power the product on and use it on the model. Click keys, drag or scroll knobs, push them, flip switches, drag the joystick and sliders; on the keyboard 1–9 press keys and the arrows turn knobs. Lights glow, screens show what runs, the speaker beeps, the battery drains and charges by the power engine's numbers (time can run faster), and unplugging USB cuts the power.
- Four ways to make it work: an interface designed on the screen with no code (text, live values, bars, boxes, circles, lines, clock, battery; several screens; key 1 next, key 2 back), Okay BASIC (our own language: line numbers or labels, IF/FOR/WHILE/DO/GOSUB, arrays, strings, graphics, KEY/PRESSED/KNOB/SWITCH/SLIDER/JOYX/JOYY/BATTERY, LED, BEEP; friendly errors with the line), MicroPython (the real interpreter in WebAssembly in a worker, with an
okay module for the device; while True and time.sleep behave as on a board) and Linux (a real Linux 6.8 kernel with BusyBox booting in the v86 emulator, its console on the product's screen and in a terminal; the brain becomes a Raspberry Pi Zero 2 W; v86 is x86, so it stands in for the Pi's ARM chip). "Edit as code" turns an interface into BASIC. Examples for each.
- Screens are parts: 0.96" and 1.3" OLED, 1.54", 2" and 2.8" colour, 1.28" round, 1.54" e-paper and 5" displays, each with its real resolution, window, module keep-out, controller, power and pins. OLEDs show lit pixels in their tint, e-paper shows ink, round panels show their circle.
- Make anything: round (circle or ellipse) and pill bodies beside the box, and many more parts: slide, toggle and rocker switches, a thumb joystick, a slide potentiometer, a dial, a speaker grille, a microphone port, a camera window, 3.5 mm audio and DC jacks, USB-A, microSD and vent slots. Every part cuts real geometry, has drawings, checks, cost and (where it draws power) a component. The interpreter and the AI engineer know them all; the palette's more sheet lists every part with search.
- Tools, like a CAD program: click a part or the body to select it, then choose move (drag it, or slide it along one axis by its arrows), rotate (turn a top part by its ring, 15° steps, ⌥ for any angle) or resize (the body's arrows). Nothing hangs off the model until a tool asks for it. Keys: V, M, R, S, Esc. Parts keep their rotation in the cutouts, drawings and checks.
- The web app and the Mac app are cross-origin isolated (COOP/COEP) so MicroPython can share memory with its worker.
- Pre-launch password gate on okaydesigner.com. Until launch, opening a page asks for the shared password (a noindex "coming soon" page); the right one is remembered for 30 days.
site/password-gate.js is the handbook's shared gate, unchanged; the Worker secret is GATE_PASSWORD. /api/* (OkayLogin sign-in and its callback, /api/me, saved designs, the Mac app's account calls) and everything that isn't a browser page load keep working without it.
- The brand is written in lowercase: the okay designer, the okay company, okay engineering (the site, the home screen, the AI's prompt, the docs).
- Migration: none. Remove the
GATE_PASSWORD secret at launch.
0.4.0
2026-10-18download .dmgunsigned build: macOS may refuse it; use 0.26.1- Design by hand in the 3D view. Click any part to select it and drag it where you want it: it snaps to a 1 mm grid (0.5 mm or free from the dock; hold ⌥ for free), lines up with the parts around it (blue guides), stays inside its face, and shows its keep-out, red when it would clash. The USB-C port slides along its wall and hops to another wall. Drag the orange arrows to resize the enclosure. Drag a key, button, knob, light or USB-C in from the parts palette, or click to add one in a free spot. A small bar on the selected part duplicates or deletes it.
- Undo and redo for every change (⌘Z, ⇧⌘Z), arrow keys to nudge (⇧ for 5 mm), ⌫ to delete, ⌘D to duplicate, Esc to deselect. The dock under the model has undo, redo, top, front, back and 3/4 views, and the snap setting.
- Home, the new dashboard the app opens on: start a new product from one box, see your products as cards with a picture, size and parts (open, duplicate, delete), and every setting in one place (your account, your company and logo with a preview, the AI engines with their status, about). Settings moved here from the dialog.
- Signed out, your products are kept on this computer; signing in with OkayLogin moves them into your account. Each design saves itself (shown next to its name) with a fresh picture.
core/place.ts: the placement rules (limits, snapping, lining up, clashes, free spots) shared by dragging, adding and duplicating, with tests. Account designs gain a picture and a summary (migration 0002_design_cards.sql) and a duplicate route.
0.3.0
2026-10-18download .dmgunsigned build: macOS may refuse it; use 0.26.1- Sign in with OkayLogin, the one login for everything Okay: sign in at the top of the app (and on okaydesigner.com). Signed in, every design saves itself to your account and appears under your designs in step 01 on any computer, on the web or in the Mac app; open or delete them there. The app still works fully without an account, and your API keys never leave your computer.
- okaydesigner.com/api: OkayLogin sign-in (
/api/auth/okaylogin/start, /callback, /api/auth/signout), /api/me and /api/designs (D1 okaydesigner), with a signed 30-day session cookie and same-origin checks on every write.
- The Mac app signs in through its own OkayLogin window (
electron/preload.cjs), and makes the account requests itself so the session never reaches the page.
0.2.0
2026-10-18download .dmgunsigned build: macOS may refuse it; use 0.26.1- See it where it lives (step 05): the product in a real setting at real size, lit like a product shoot: an Apple-style showroom on a white plinth, an oak desk, a living room, a dark studio. "auto" picks the setting from how the product is used. Six camera angles, a turntable, drag to pivot to any angle, and a high-resolution still.
- Photos with real people: the product, rendered from the chosen angle, goes to Google's image model (Nano Banana) with a scene that fits how it's used (in a hand, worn, at a desk, at home) and comes back as a photograph. Labelled "AI image", because an image model can change details; the 3D view, drawings and files stay the reference. Uses the person's own Google AI key, kept on their computer.
- Brighter, more realistic aluminium; the stage title turns light on dark scenes.
0.1.0
2026-10-18download .dmgunsigned build: macOS may refuse it; use 0.26.1- the okay designer on the web at okaydesigner.com/app: the same app, with its own security policy for the WebAssembly engine and the AI calls. The site gets "open in your browser".
- okaydesigner.com: the website, with screenshots from the packaged app and a download that streams the installer from R2. The domain moved to Cloudflare.
?demo=N&tab=… (and OD_DEMO in the desktop app) opens an example straight into a step.- First version. Describe a product in plain words and get a real design: a parametric enclosure built by OpenCascade (STEP and STL), parts laid out from a library with real cutouts, mechanical checks, the electrical model with a power engine (average and peak power, battery life, days per charge, standby, charge time, regulator loads, case heating) and circuit checks (voltage, regulator headroom and dropout, USB limits, battery C-rates, pins), a BOM with a cost estimate against target, a CircuitPython firmware scaffold, A3 manufacturing drawings with the maker's logo, a spec sheet, a user guide and a patent draft.
- The AI engineer (Claude, tool use) with the person's own key, or the interpreter on this computer without one.
- Desktop app (Electron) and a macOS installer (unsigned).