Pimp My IDE / garage dispatch
Back to garage
September 30, 2026 | solid modeling / distance fields / WebGPU

Inspect the field before you trust the solid.

Halfspace puts distance fields beside the model instead of hiding them behind the final mesh. That changes what an IDE can help a modeler see, debug, and explain.

A solid-looking render can hide a broken field. Keep the field values, gradients, export, and runtime proof in the review.

The final surface is only one view.

Halfspace is Matt Keeter's experimental IDE for solid modeling with distance fields. A model can combine predefined shapes with Rhai scripts. The application can rasterize images and export triangle meshes through the Fidget geometry kernel.[1]

The project puts the distance field in the editor. That matters because two fields can mark the same points as inside or outside while behaving differently near the boundary. Keeter shows a sawtooth field with a jump discontinuity. Its sign looks right, but its normals point the wrong way and produce bad shading.[1]

A plausible silhouette does not prove a healthy field.

The representation becomes a debugging tool.

Fidget defines an implicit surface as a function that maps x, y, z to one value. A negative result is inside the model. A positive result is outside. The zero crossing is the surface.[2]

Fidget also evaluates partial derivatives. At the surface, those derivatives approximate the normal used for shading. Halfspace can therefore expose field lines and gradients that a mesh-only editor would discard. The editor is useful because it keeps the low-level representation inspectable while a standard library handles common shapes and transforms.

The IDE is also a kernel test.

Halfspace is a real application built on Fidget, not a separate product wrapped around a finished library. The writeup says the application drove GPU rasterization and post-processing work in Fidget. That work removed CPU round trips from the rendering path and gave the native and web builds one canonical renderer.[1]

The stack uses Rust, egui, wgpu, Rhai, Rayon, and WebAssembly support. The repository documents both native and web builds. It also states that the project is underdocumented and points users to its examples and Fidget's Rhai documentation.[3]

Experimental means the brake stays on.

Keeter warns against load-bearing use and expects compatibility breaks. The web demo also has platform limits. Its project page notes WebGPU trouble on mobile Safari and says multitouch pan, tilt, and zoom are not ready.[1]

This review fetched the demo and received HTTP 200. The headless Linux browser could not get a WebGPU adapter, so it displayed the project's explicit initialization error instead of the modeling interface. That confirms the fallback message works here. It does not prove editing, rendering, or export behavior.

Interactive makeover / field continuity workbench

Change the inspection layer

Traditional purpose replaced: a static final render. Better version: switch between surface, field, and gradient views, then copy a review card that keeps missing evidence visible.

Set the probe

These modes teach review order. The diagram is illustrative and has no geometry kernel behind it.

Inspection layer
Review-card sections
Review card draft0 of 4 sections selected
Illustrative probe glass

Field continuity workbench

Probe 1 / 3: zero surface visible

Check the silhouette, then keep going.

The surface view can reveal clipping and obvious shape errors. It cannot show whether nearby field values or gradients are healthy.

Selecting every section means the review-card structure is ready. It does not prove field continuity, normal quality, export correctness, or runtime support.

Inspection order / four records

Keep the low-level view in the handoff.

01 / SCRIPT

Pin the expression

Save the source revision, parameters, standard-library calls, and example name.

02 / FIELD

Inspect the values

Find discontinuities, wrong signs, crowded gradients, and the exact region that fails.

03 / OUTPUT

Check the artifact

Open the exported image or mesh with a separate viewer or checker.

04 / RUNTIME

Replay the target

Record the browser or native build, GPU path, failure message, and result.

Sources read

Source log and evidence boundary
  1. Matt Keeter, "Halfspace", read September 30, 2026. This first-party writeup defines the project, explains its distance-field focus, documents the sawtooth discontinuity example, names the application stack, and warns against load-bearing use.
  2. Matt Keeter, "Fidget", read September 30, 2026. This first-party technical writeup defines the implicit-surface function, derivative evaluation, rasterization, meshing, and known meshing limits.
  3. Halfspace repository, inspected September 30, 2026. Its README documents web and native build routes, examples, scripting documentation, and the author's stated use of language models. The GitHub API reported an active MPL-2.0 repository on the main branch.
  4. Hacker News discussion, exact item 49913350, checked September 30, 2026. It led to the project writeup. It had no comments when checked and is not evidence for project behavior.

Evidence boundary: this page reads the project and kernel documentation and verifies that the web artifact responds. The current browser lacked a WebGPU adapter, so the actual editor did not start. The interactive workbench on this page is an explanatory SVG and checklist. It is not Halfspace output.