What the source published

Matt Keeter has released Halfspace: an experimental IDE for solid modeling built around distance fields, not the surface-stitching of traditional CAD. It is a showcase application for his Fidget geometry kernel: models are rasterized into images in real(ish) time inside the GUI, and finished work can be exported either as images or as triangle meshes ready for 3D printing.

Diagram of Halfspace and the Fidget kernel: modeling scripts rasterized and meshed by Fidget
How Halfspace and the Fidget kernel work together: models rasterized live, exportable as images or triangle meshes (image: Matt Keeter's original post)

The author opens with a deliberate disclaimer: this is not vibe-coded. He has been writing it by hand since April 2025, and the underlying Fidget kernel dates back to 2022. Keeter's background is in CAD/CAM software with an emphasis on 3D printing — since his Master's thesis he has worked on geometry kernels based on implicit surfaces, because such kernels can conceivably be written and fully understood by a single person or a small team, making them a good fit for personal-scale fabrication software.

His motivation comes from an observation: writing low-level implicit surfaces is like writing assembly — low-level, powerful, and annoying. Faced with the pain of assembly, people usually take one of two paths: build high-level abstractions (here, a standard library of shapes and transforms like sphere, box, translate, scale), or make assembly itself less painful to write (his favorite example is Kartik Agaram's Mu, which wraps emulation, tracing, and time-travel debugging around a subset of x86 assembly). Halfspace takes both paths: it ships a small but growing standard library, and it supports incremental modeling — a complex model can be split into smaller pieces, each parameterized and visualized individually.

The project is open source under the MPLv2 license. The author calls it a thing that exists and invites everyone to try it, while warning against using it for anything load-bearing; bug reports go to GitHub issues or discussions. He plans to keep working on it until he runs out of things to learn from it.

Sources: [1]

Try it yourself: seven steps to play with this distance-field IDE

  1. Open the web demo in a desktop browser (the author notes WebGPU issues on mobile Safari, and pan/tilt/zoom interactions are not designed for multitouch yet — desktop is the best experience).
  2. Build your first model without writing code: combine standard-library primitives like sphere and box with transforms like translate and scale — the Halfspace equivalent of a high-level language.
  3. Split an ambitious model into smaller parts: parameterize each part and preview it on its own, assembling only once each piece looks right — incremental modeling is the core workflow of this IDE.
  4. Go lower level with Rhai scripts to hand-tune distance-field expressions directly, instead of only combining CSG unions, intersections, and differences.
  5. Turn on distance-field visualization and read it like a topographic map: sign defines inside vs. outside (blue/orange), the white line is the zero boundary, and contour spacing exposes gradient problems. If you see a vertical edge jumping from blue straight to orange without crossing white, that is a bad C0 discontinuity — fix it.
  6. Export when happy: render an image for show, or export a triangle mesh for 3D printing — solid modeling guarantees every point has a definite inside/outside, so prints do not fail on hollow geometry.
  7. Remember it is experimental and APIs will keep breaking: do not fight weird behavior alone — file a GitHub issue or open a discussion; the author explicitly welcomes feedback.

Sources: [1]

Deep dive: why put distance fields front and center

First, what 'solid modeling' means: it only cares about objects with a definitive inside and outside — pick any point in space and you can say whether it is inside or outside the model. That sounds obvious, but plenty of modeling does not care: open any video-game model viewer and you will see infinitely thin textured walls built from a single fan of triangles. Keeter wants objects that can be physically realized, so the kernel must guarantee solidity. Mainstream CAD uses boundary-representation (B-rep) kernels that stitch many surfaces into a solid body — a tremendously hard problem, since the intersection of two NURBS surfaces may not even have a closed-form solution. The advantage of implicit surfaces is precisely that one person can write the whole thing and understand it completely.

Halfspace's key design decision is to not use Fidget purely at the constructive-solid-geometry layer (stacking spheres and cubes with union/intersection/difference), but to put the underlying distance fields in the foreground. The author demonstrates why with a sawtooth wave: two distance fields have identical signs at every point in space, but different values. The first field is badly behaved: at the sawtooth's vertical edge the field jumps from inside (blue) directly to outside (orange) without crossing zero — a C0 or 'jump' discontinuity. Fidget computes normals with automatic differentiation, so the normals across this boundary point the wrong way.

Bad sawtooth distance field: values jump from inside to outside at the vertical edge, a C0 discontinuity
A bad distance field: at the sawtooth's vertical edge, blue (inside) jumps straight to orange (outside) without crossing the white zero line — a C0 discontinuity that breaks normal computation (image: Matt Keeter's original post)

Wrong normals mean wrong shading in 3D: the author shows a cabin rendering with visibly incorrect shingle shading — a real failure case lifted from one of his earlier blog posts. With distance fields visualized front and center, this class of bug becomes diagnosable at a glance.

Cabin rendering with incorrectly shaded shingles — a real failure caused by a bad distance field
What a bad distance field costs in practice: a cabin whose shingle shading is completely wrong (image: Matt Keeter's original post)

And once visible, it is fixable: the author tweaks the sawtooth field so its gradient is 1 everywhere (it had been bunched up on the diagonals), evening out the contour lines. Fidget does not require unit gradients for correctness, but uniform gradients make algorithms better-behaved — improving, for example, mesh quality.

Fixed sawtooth distance field with uniform gradients and no discontinuities
The fixed field: gradient tuned to 1 everywhere, contours even, algorithms better-behaved and meshes cleaner (image: Matt Keeter's original post)

The other highlight is cross-platform engineering: the author deliberately targets both web and native. In an era of supply-chain attacks, sharing a web link for casual use beats asking someone to compile and run your code. He assembled a 'Halfspace stack': Rust for the app, hand-invoked wasm-bindgen for web builds, egui for the GUI, egui_dock for window-and-tab abstraction, wgpu for both UI rendering and GPU compute, Rhai for scripting, and Rayon plus wasm-bindgen-rayon for parallelism (threads cannot be spawned on the web, so there is also a thread pool for short-lived background tasks), along with web-time and a homebrew worker pool for off-thread async GPU rendering. He says he has complaints about every layer — but overall, it just works.

Sources: [1]

How to read it

Hand-writing a geometry kernel in 2026 — and disclaiming 'not vibe-coded' up front — is itself a statement: some software is valuable precisely because its author can hold the whole thing in their head. AI coding excels at assembling known patterns quickly, but projects like Halfspace are about exploring the unknown — 'put distance fields in the foreground' and 'make assembly pleasant to write' are not designs you can prompt out; they require years of living inside implicit surfaces. It is the flip side of the recent 'vibecoding isn't fun' debate: the joy of hand-writing comes from a sense of control over the essence of the problem.

The second takeaway is 'make implicit state explicit': distance fields used to hide inside the kernel; Halfspace draws them as topographic maps, turning debugging from mysticism into reading a picture. The idea transfers — any system with complex hidden state and hard-to-locate bugs (physics simulators, layout engines, even an AI agent's intermediate reasoning) benefits from being drawn before being optimized. For makers eyeing 3D-printing side projects, the message is blunter: solid modeling's 'guaranteed printable' beats 'looks good' every time — a veto-level criterion when choosing tools.

Sources: [1]

Key takeaways

  • Halfspace = experimental solid-modeling IDE + foreground distance fields + Fidget geometry-kernel showcase; live rasterization, exportable as images or triangle meshes.
  • Author Matt Keeter: CAD/CAM background, hand-written since April 2025, explicitly not AI-generated; the Fidget kernel dates to 2022.
  • Design philosophy: writing implicit surfaces is like writing assembly; Halfspace offers both a standard library (the high-level-language route) and incremental visual modeling (the make-assembly-pleasant route).
  • Signature case: a C0 discontinuity in a sawtooth distance field breaks normal computation and visibly ruins cabin-shingle shading; retuning the gradient to 1 everywhere makes algorithms better-behaved.
  • Stack: Rust + wasm-bindgen + egui + wgpu (UI and GPU compute) + Rhai scripting + Rayon, shipping web and native from one codebase.
  • Experimental: not for load-bearing use, APIs will keep breaking; open source under MPLv2, GitHub issues welcome.

Sources: [1]