← Selected work

A project by Jason Maitland / Make

Forge · Keyboard Maker

From personal geometry to something you can make.

A browser workshop for keyboard layouts, cases, wiring and keycaps. The project connects the feel of a physical object with the geometry, export and recovery tools needed to build it.

In practiceA wiring plan survived layout changes, saving, reopening and export in the local development build. Physical fit and electrical operation remain to be tested.

Public demoPrivate sourceActive development
Open Keyboard Maker
Forge showing a split keyboard assembly and its controller bay.View full size ↗
In the project

Layout becomes an assembly: the newer Forge work brings key positions, case geometry and controller space into the same view.

About this image

Local Forge development · not all features are public · Repository evidence reviewed 7 September 2026
Revision: Image 4401237873a7

The problem

A keyboard can look right on screen and still fail at the workbench: a thumb cluster may be awkward, a controller may not fit, or a keycap connector may prevent a switch from moving. Personalisation needs a path through those practical constraints.

What I built

A browser-based 2D/3D workshop with editable layouts, cases, controller spaces, local project recovery and fabrication exports, plus a parametric keycap and engraving workspace.

The interesting part

Mechanical geometry, electrical identity and printable output must agree while remaining honest about what has actually been validated.

My contribution
Project creator responsible for the browser workshop, mechanical design workflow and electrical planning.
Evidence
Real keyboard assembly and wiring captures, exported circuit and key-map SVGs, and the public keycap workflow.
Access
Private source; public browser workshop. Development captures include features that have not been publicly deployed.
My decisions & how it was built
What I own
I connect layout editing, printable geometry and saved wiring into a browser workflow a maker can inspect and export.
A decision I made
I gave keys stable electrical identities, so moving a thumb cluster does not silently reassign its row, column or controller pin.
What it builds on
React and TypeScript provide the application structure; Three.js renders assemblies and Manifold WebAssembly performs solid operations. Forge supplies the design model, editing workflow, constraints and export rules.

01 / The work

From a layout to something you can make.

The computer should fit the person.

Keyboard design starts with the things a hand actually touches: where a key sits, the angle of a thumb cluster and the curve of a keycap. Those choices quickly meet less visible constraints—switch travel, walls, mounting space, wiring and connector clearance.

Forge brings that work into a browser workshop. A persistent canvas stays visible while focused stations organise Keys, Shape, Build, Wire and Check. A design can move between a precise 2D plan and a 3D assembly without becoming a different project.

Give a promising layout an electrical plan.

The newer split-keyboard workflow begins with one authored half and a mirrored physical assembly. Thumb groups can be added, moved and rotated as a single undoable change. Controller bays combine a board placement, reserved volume and modelled USB opening, so the surrounding case has something concrete to accommodate.

The saved handwiring plan keeps a switch’s electrical identity when its physical position changes. Each half has its own pin assignments. The resulting circuit diagram, physical key map and connections table describe different views of the same plan, rather than asking the maker to infer wiring from a 3D render.

The keycap became a workshop of its own.

Keycap mode extends from engraving an imported blank to generating the body and switch connector parametrically. Text and artwork become real cutting geometry. The tool inspects the resulting solid before enabling STL export, and portable keycap projects retain their source assets.

Iteration exposed mistakes that a pleasing preview could hide. Broad support ribs conflicted with switch travel; they were replaced by a compact connector. Independent surface-curvature controls initially produced a flat plateau where the axes met; the model was corrected to form a compound surface. These were changes to the object, not just its appearance.

A green preview is the beginning of validation.

A watertight mesh is useful evidence, but it cannot tell me how a particular resin shrinks or whether a keycap survives repeated removal. The workflow therefore separates geometry checks from slicer inspection, test coupons, switch travel and durability. The experimental PCB exporter also blocks unsupported configurations and still requires downstream electrical review.

Reliability matters before fabrication, too. A public black-screen incident traced back to cached HTML referencing older assets. The release process now retains immutable asset generations, installs the entry page last and refreshes stale cache without deleting saved keyboard projects. Recovery is part of the workshop experience.

Useful software, with the workbench still in the loop.

The public app has released layout and keycap tools. The newer keyboard assembly and saved-handwiring work has been exercised locally on desktop and mobile, including editing, saving, reloading and downloading the plan. That newer workflow has not been publicly deployed.

The captures show real interfaces and actual exports. They are not photographs of a finished keyboard. Resin fit, complete switch travel, controller mounting, soldered operation and long-term durability still need physical tests.

How it connects

A layout has to become a build.

Geometry, electrical planning and fabrication answer different questions.

  1. 01

    Shape

    Choose positions, spacing, keycaps and the surrounding geometry.

  2. 02

    Plan

    Inspect the assembly and the controller space; assign the wiring.

  3. 03

    Make & check

    Export the model and wiring references, then validate fit and electrical behaviour.

The exported drawings are real tool outputs. A preview or schematic alone does not establish physical fit or electrical acceptance.
Diagram source

Verified workflow diagram · reviewed 7 September 2026
Source revision: ec3e417fdaeb

03 / Choices & trade-offs

The decisions that shaped it.

01

Keep the workshop in the browser

Editing, previews, local drafts and normal exports run without an account or required backend. Portable project files provide an explicit way to back up or move work.

02

Preserve electrical identity through geometry edits

Saved wiring uses stable key and physical-half identities. Moving a thumb cluster does not silently reassign its row, column or controller pin.

03

Make unsupported output visible

Geometry validation and export rules distinguish warnings from conditions that must block a download. Preliminary PCB routing remains separate from the handwiring plan.

04 / Iteration

What changed along the way.

  1. Layout generator

    Make geometry editable

    Templates, key transforms, outlines and 2D/3D views established a browser-native design space.

  2. Workshop

    Organise work around making

    Focused stations, recovery, design-health feedback and safer release packaging made the app easier to return to and trust.

  3. Fabrication detail

    Follow the object into its constraints

    Keycap solids, switch connectors, controller bays and saved wiring bring the project closer to physical assembly, while test coupons and electrical review remain explicit.

05 / Under the hood

For the curious.

Architecture, implementation and the details behind the interface.

React, TypeScript and browser geometry

The canonical workshop uses a shared typed design model, SVG editing and a lazy-loaded Three.js assembly preview. Fabrication output follows the model rather than a screenshot.

Real mesh operations

Manifold WebAssembly performs keycap Boolean operations locally. Mesh topology, remaining material and connector constraints decide whether export is available.

Portable work and deliberate recovery

Versioned local drafts and bounded undo support everyday editing. Validated project downloads preserve complete designs; local storage is a convenience, not a substitute for a backup.

06 / Current state

Where it stands.

What exists today

The public workshop is available. Assembly and wiring captures show newer development work; printed fit and electrical operation still need physical testing.

Where I’m taking it

  • Print calibration coupons in the intended resin and check seating, full travel, removal force and repeated-use damage on the exact switch.
  • Check the newer controller bays and handwiring references against a physical build before relying on them for fabrication.
  • Keep PCB routing, connector definitions and downstream electrical checks clear as the workshop expands.

Another thread to follow

Calidaw

A music studio humans and agents can play together.

Continuum

The system behind everything I build.

Have something like Forge · Keyboard Maker in mind?