SketchForge: a local-first browser 3D editor for cut-and-export work

The gap SketchForge fills between primitives and full CAD

Most people who need one bracket, one phone stand or one enclosure face a bad choice. A full parametric CAD package installs hundreds of megabytes, asks for an account, and expects you to learn a constraint solver before you can cut a hole. A pure mesh toy is fast but cannot round-trip exact geometry. SketchForge positions itself in that gap. The README describes it as "a lightweight CAD-style workspace for people who want to sketch, cut, and export 3D models quickly", built for "the satisfying loop": drop a shape, resize it, rotate it, make another shape a hole, group the result, import an STL, export the model.

The intended user is not a mechanical engineer doing assemblies. It is a teacher running a classroom, a FabLab operator with a shared workstation, or a maker who wants a part out the door. The README names teachers, classrooms, shared computers and local network hosting as the audience for the Docker path. That framing matters, because it explains most of the design decisions: no login, no server-side project storage, and exports that download through the user's browser rather than through a SketchForge cloud service.

The feature list is concrete rather than aspirational. Primitives include boxes, cylinders, spheres, cones, pyramids, wedges, text, roofs, half spheres, torus shapes and tubes. On top of that sits a solid-and-hole workflow: a shape can be turned into a cutter, and grouping turns solid plus cutter into final geometry. There is a Boolean Intersection operation that keeps only the overlap between selected solid and hole shapes, plus chamfer and fillet on selected CAD edges with history controls for removing applied edge features. That last pair is the part most browser editors skip.

What actually runs in the tab: Next.js, Three.js and Manifold

The README states the stack plainly: Next.js, React, TypeScript, Three.js, and Manifold/CSG geometry tooling. The repository layout backs this up. package.json defines a private workspace named sketchforge at version 1.0.9, with a main entry at apps/desktop/main.cjs and scripts that build apps/web with Next.js. The top level splits into apps/, deploy/, docs/, scripts/ and tests/.

Geometry work has a visible footprint in the build. The predev and prebuild scripts both run copy:occt, which executes scripts/copy-occt-wasm.mjs. That is a WASM copy step for OpenCascade Technology, the kernel behind the STEP and B-Rep round-tripping the README advertises. It runs before dev and before build, so a fresh clone that skips npm install will not have the kernel assets in place. The export script adds a second guard: it sets STATIC_EXPORT=true, builds the web app, then runs scripts/verify-static-worker-assets.mjs to check that the worker assets a static export needs are actually present.

Data flow is the interesting part. Projects live in browser storage, with generated project thumbnails, per the README. When you run the Docker path, the container serves the app files and provides a shared projects directory at SKETCHFORGE_SHARED_PROJECTS_DIR, but the README is explicit that projects stay in each user's browser storage and that exports download through the browser. So the server is a delivery mechanism, not a database. That is a deliberate trade-off: it means no model data leaves the machine, and it also means clearing browser storage clears the work.

One small detail worth noting is the camera shortcut. Pressing O in the editor switches between perspective and orthographic projection, and the README says the current view direction and framing are preserved across the switch. That is the kind of thing you only get right on purpose.

Installing SketchForge with Docker Compose or npm

The README offers two paths and recommends Docker when you are unsure. The table lists Docker / FabLab server for teachers, classrooms, shared computers and local network hosting, and local development for developers who want to edit the code.

For the Docker route you need Docker Desktop or Docker Engine, Compose (included with modern Docker Desktop), and the repository downloaded on the server machine. From the project folder, the Compose build path is:

docker compose -f deploy/docker/compose.yaml up --build -d

The README warns that the first start can take a few minutes because Docker builds the app. If you would rather not build, there is a prebuilt Compose file and a standalone container. The standalone form, quoted from the README, pins the shared projects directory and publishes port 3000:

docker run -d --name sketchforge --restart unless-stopped \
  -p 3000:3000 \
  -e SKETCHFORGE_SHARED_PROJECTS_DIR=/data/projects \
  -v sketchforge-shared-projects:/data/projects \
  ghcr.io/formsmith746/sketchforge-3d:latest

After that, the README says to open http://127.0.0.1:3000/ on the same computer. If that page loads, SketchForge is running. The container listens on port 3000 and also accepts connections on port 80 for backward compatibility with older UnRAID templates.

For local development, clone the repository and use the npm scripts. Note that predev and prebuild run the OCCT WASM copy step automatically, so you do not invoke it by hand:

git clone https://github.com/Formsmith746/SketchForge-3D.git
cd SketchForge-3D
npm install
npm run dev

The dev script runs next dev against apps/web. There is also npm run typecheck, npm test via vitest, npm run test:e2e and npm run perf, plus npm run ci, which chains typecheck and test. If you want a container image built from your own checkout rather than from GHCR, npm run docker:build builds deploy/docker/Dockerfile as sketchforge:local.

The first real use is the README's loop: drop a primitive on the workplane, resize and rotate it with the transform handles, add a second shape and mark it as a hole, group the two, then export. Export supports STL, OBJ and STEP, for selected objects or the whole scene.

The macOS desktop build and its Gatekeeper friction

GitHub releases include macOS DMG files for Intel (x64) and Apple Silicon (arm64), and the README tells you to pick the file matching your Mac. The install sequence is the standard drag-to-Applications dance, followed by a step people skip: control-click SketchForge.app in Applications, choose Open, then Open again. The README also says not to launch the app from Safari's Downloads folder or from the mounted DMG, and to copy it to Applications first.

Unsigned releases carry -unsigned in the file name and trigger a Gatekeeper warning. If macOS does not offer the Open option at all, the README gives a Terminal workaround:

xattr -dr com.apple.quarantine /Applications/SketchForge.app
open /Applications/SketchForge.app

That command strips the quarantine attribute from the app bundle. It is a real, documented workaround, and it is also a signal about the project's release posture: shipping unsigned builds means every macOS user pays a manual step. For a classroom where you control the machines, that is a one-time cost. For distributing to strangers, it is friction you should count.

The README also covers macOS virtual machines, where hardware WebGL may be unavailable. In that case it gives a launch command with software rendering flags:

/Applications/SketchForge.app/Contents/MacOS/SketchForge \
  --use-angle=swiftshader \
  --enable-unsafe-swiftshader

Software WebGL will not match a discrete GPU. The flags exist because the alternative is a blank canvas, not because the experience is equivalent.

Where SketchForge is the wrong tool

The README is candid about scope, and the honest reading is that this is not a parametric modeller. There is no mention of a constraint solver, a feature tree with editable dimensions, or assembly mates. If your workflow depends on changing a hole diameter by editing a number and having everything downstream rebuild, SketchForge's primitive-plus-boolean approach will feel like redoing work. The README's own loop is shape-first: drop, resize, rotate, cut, group, export.

Storage is the second boundary. Projects live in browser storage. The Docker deployment provides a shared projects directory on the server, but the README states that projects stay in each user's browser storage and that SketchForge does not upload models to a SketchForge cloud service. Read that carefully before you plan a classroom around it. A shared machine with multiple students means multiple browser profiles, and a browser data wipe means lost work. The README does not document rollback, project export as a portable archive, or a server-side backup path, so you should not assume one exists.

Third, the desktop story is macOS-only in the README. Releases are described as DMG files for x64 and arm64. Windows and Linux users get the browser or Docker path, which is fine, but there is no desktop installer for them in what the README documents.

Finally, the chamfer and fillet tools carry a specific constraint worth knowing. The README advertises "rotated solid edge treatment": chamfer and fillet preserve analytic box topology after one-, two-, or three-axis rotations. That phrasing is narrow on purpose. It describes box topology under rotation, not arbitrary imported meshes. If you import a complex STL and expect clean fillets on its edges, the documentation does not promise that.

How it compares with Tinkercad, FreeCAD and Onshape

The three names people search alongside SketchForge are Tinkercad, FreeCAD and Onshape, and each differs in a way that matters.

Tinkercad is the closest in spirit: browser-based, primitive-driven, aimed at beginners. The difference is where the work lives. Tinkercad is a hosted service with accounts and cloud storage. SketchForge's README makes the opposite promise: no login, no server project storage, projects in browser storage. If your constraint is that student models must not leave the building, that is the whole argument. If your constraint is that students must reach their work from any machine, Tinkercad's model is the one that works and SketchForge's is the one that does not.

FreeCAD is the opposite trade in every dimension. It is a desktop parametric modeller with a feature tree, a constraint-based sketcher and a long history. It is heavier to install and slower to learn, and it gives you editable history that SketchForge does not document. SketchForge's advantage is time-to-first-part and zero install for the browser path. FreeCAD's advantage is that the twentieth revision of a part is cheap.

Onshape is cloud CAD with real versioning and collaboration. SketchForge does not compete there at all. The README's storage model is per-browser, and the Docker path explicitly keeps projects local to each user's browser rather than centralising them. Onshape solves the multi-user problem by owning the data. SketchForge solves the data-ownership problem by refusing to own it.

On the geometry side, SketchForge's STEP and B-Rep round-tripping is the feature that separates it from mesh-only browser editors. The OCCT WASM copy step in package.json is the mechanism behind that claim, and it is the reason the build is not a single static bundle.

Licence and what upgrades cost you

SketchForge is licensed AGPL-3.0-only, stated in package.json and shown as an AGPLv3 badge in the README. For a teacher running it on a classroom server, that is unremarkable. For anyone embedding SketchForge into a product, the network clause is the part to read with a lawyer rather than with an article. AGPL-3.0 reaches users who interact with modified software over a network, which is exactly the deployment shape the Docker path creates. I am not giving legal advice, and the LICENSE file is the authority.

The upgrade picture is mixed in an informative way. Releases listed include v1.0.3 and v1.0.2, both dated 2026-08-17, and an earlier checkpoint-rotated-resize-fix-20260612. The README badge shows version v1.0.9 while package.json also reads 1.0.9, so the badge and the manifest agree even though the newest GitHub release in the README is v1.0.3. That gap is worth checking before you pin a version for a classroom image: decide whether you are tracking the package version or the release tag.

The last push to the repository was on 2026-09-02, and the repository is not archived. The upgrade cost itself is modest if you use the prebuilt images, because the Compose file and the GHCR image abstract most of the build. If you build locally, the first Compose start takes minutes, and the OCCT WASM copy step runs on every predev and prebuild. There is no documented migration path between project formats, so treat browser storage as the source of truth and do not assume an upgrade will move your existing projects for you.

Editorial conclusion

Adopt SketchForge if you want a browser workspace for primitive-based parts, hole cutting and STL round-tripping without accounts, and if AGPL-3.0 fits how you distribute it. Skip it if you need parametric history, constraint solving or multi-user cloud storage: the README describes storage in each user's browser, not a shared project server. Before rolling it out to a classroom, run the Docker Compose path once and confirm that http://127.0.0.1:3000/ loads, then check whether your users' browsers keep their local project data across a wipe.

Frequently asked questions

Official sources

1. Formsmith746/SketchForge-3D on GitHub
2. License: AGPL-3.0
3. Project website
4. README
5. Releases