glisten is a metaball-first blobjectery — a workshop for making blobjects. You don't build topology; you drop soft primitives into space and let them fuse, like clay, into smooth organic forms. It's for the early, exploratory part of product and jewelry design, where the form matters more than the mesh.
How to use it
- Add a form — click a primitive in the top rail: sphere, capsule, torus, cone, box, cylinder, Poly (a polygon prism — set its Sides 3–33, turn it into a Star, or Taper it to a point for a pyramid; Round softens the edges), Wire (a freeform tube — see below), and Lava (a cluster of animated wax blobs — see below). It drops into the scene.
- Wire (the curve icon at the end of the rail) is a freeform tube through movable points — it resolves as one smooth tapering curve, so you can shape a cherry stem, a vine, a handle or an arm in a single stroke. It starts as a gentle 3-segment arc; drag the pink dots in the scene to bend it, and in the inspector set the number of Points, the Joint blend (how rounded the bends are), and a Thickness per point (taper it thick-to-thin). It fuses, booleans, colors, weighs and exports like any other form.
- Lava (the last icon in the rail) drops a cluster of hot wax blobs drifting through the whole local volume like a slow turbulent fluid, in every direction — not a lamp column. Blobs aren't all plain spheres — a few of them stretch into pointed, egg-like shapes, and nearby blobs trail a thin connecting string as they drift apart, the way real lava-lamp wax does. Dial Blobs (count — past 32 the slider reads red, a heavier compute cost), Size and Size random, Speed (drift rate), Randomness (decorrelates each blob's orbit so the motion never looks synchronized), Cohesion (how readily blobs melt into each other as they pass) and Temperature (hot = looser cohesion & faster drift, cool = the opposite), then reroll the Seed for a new arrangement. Animate (top of its inspector) is on by default; switch it off to freeze the current pose into a clean pose to sculpt around. It's a closed-form field like any primitive — scrubbable and bakeable — so it fuses, booleans, colors, weighs and exports exactly like the rest.
- Fuse — move two forms near each other and they melt into one body (osmotic union). Subtract carves instead.
- Select — click any form. Its wireframe ghost lights up and the gumball appears.
- Gumball (all live at once, no mode switching): colored arrows move along an axis · rings turn · cubes resize that axis · the white center drags freely on screen · the amber cube scales uniformly. Hover any handle and a label names what it does.
- Inspector (right): switch Add / Subtract / Intersect, set this form's Color and Smoothness, and tune its shape (a torus's radius & thickness, a cone's tip, a box's roundness…). Tap any value to type it exactly. For a hard, un-fused join, set Smoothness to 0. Remove it from here.
- Color tints each form; pigment shaders blend the colors where two forms fuse.
- Blend × (bottom) multiplies every form's smoothness at once — 1 = each at its own setting, >1 = molten, 0 = crisp. Edge chooses how every join is shaped: Fillet (a rounded edge) or Chamfer (a flat 45° bevel); the smoothness sets its size. Fillet is the default soft-clay look; Chamfer gives a faceted, machined edge.
- Shell hollows the body to a thin wall — per-form in the inspector, or globally with the Shell toggle & slider next to Blend ×. It lightens the piece (and drops the ring's metal weight).
- Bend & Twist (bottom bar) warp the whole body — Bend curves it along its length (the side-profile arc), Twist spirals it around that axis. Both are live; center is straight.
- Shader (bottom-left) opens a searchable library of looks — Gloss, Matte, Glass, Chrome, Gold, Copper, Pearl, Toon, Velvet, Carbon, Wax, Jade, Zebra (surface-fairness stripes), Wire, Hidden-line, Wind, Iso, Heat, Holo, X-ray, Glow, Hot Lava (black basalt crust cracked by molten veins) and Lava Lamp (glowing colored wax) and a Normals debug view. Type to filter (the names from Points — Emrld → Chrome, ZBRA → Zebra, Shade → Matte, HLR → Hidden-line — match too). Reflections and light come from a real photographic studio environment, so metals read like jewelry.
- Mirror reflects one half of space across a fold plane for symmetric rings & pendants — turn it on and pick the X / Y / Z axis (build the +side, get both). Grid toggles the ground plane & contact shadow — the floor drops automatically below taller pieces. ⟨ hide panels (top of the toolbar) tucks the left palettes into a drawer for smaller screens — a panels ▸ tab on the left edge brings them back.
- Builders ▾ is one menu that holds the parametric generators, listed by what they make — Jewelry → Ring, Grow → Tree / Figure / Creature, World → Terrain, Type → MetaText (more to come; the Flatware builders are out for rework). Pick one to start it; each opens its own panel of real-world controls.
- Ring (Builders → Ring) is a one-piece ring builder: a finger-hole mandrel at your chosen US size is a locked subtract, so everything you add fuses into a wearable band with a true bore. Pick a metal and spot price for a live weight + melt-value estimate (metal only — no labor/stones). Turn on a Stone (optional) for a faceted round-brilliant gem in a 4-prong, 6-prong or bezel setting — set its carat (the diameter follows) and prong/wall size. The prongs/bezel are real metal, fused into the band as one body and counted in the weight; the gem is a visual placeholder (you set a real stone), so it's listed separately by carat in the panel and every export manifest, not printed. Undo to leave.
- Flatware (Spoon/Fork/Knife) is paused for rework and isn't reachable from this build — the jointed-wire-body mechanism from earlier versions is kept dormant in code, not deleted, and will return once reworked.
- Grow (Builders → Tree / Figure / Creature) is the generative builder: a stochastic L-system grows a tree — pick the species (Pear · Aspen · the columnar quaking aspen · Fig · broad and gnarly · Grapevine · Olive) in the panel; leaves and fruit, never the same twice (↻ reroll) — or a Vitruvian figure (its joints carry human motion limits so a limb can't bend past a real range, and the head is sized to the build), or a creature — pick the animal (Canine · Seahorse · Octopus). All are built from a skeleton fused into one smooth skin, with printable proportions. Tick Dyad (on a tree or a creature) to grow a tree and an animal together, side by side, chosen at random — one body you can pose, melt and export as a pair. Drag the joint dots to pose (the skin follows live), flip View → wire to see the bones, and choose what the body IS: solo (a fast posable body), melted (it joins the metaball field — primitives fuse into it under Blend ×, booleans carve it, weight & exports include it, still posable), or ◍ bake to clay (freeze the pose as a captured form). Poses ride ◆ keyframes and the animated ABC export. A tree can also be DIRECTED: pick a ⌖ Target form in the Grow panel and the branches grow toward it — each step reads the target's distance field and bends home by the Bias dial (0 = free growth, 1 = pure homing); a branch that reaches the target plants a small contact node and grabs on. Roots reaching for ground, setting claws closing on a stone, vessels finding an organ — pick the form, slide the Bias, and reroll. Console types can grow custom forms via glistenGrow().
- Terrain (Builders → World → Terrain) raises a seeded ground under your work — mounds and far ridges over an island that melts into the floor (↻ reroll for new land). Dig opens a hole where the pink dot sits (drag the dot to place it) with the soil heaped at the rim — bury something, then keyframe Dig with ◆ and the ground closes back over it. Relief, Spread, Dig and Heap all animate. It's scenery: rendered in Rendre as a Soil part (drop any material on it), but never counted in weight or exports — those stay your piece.
- MetaText (Builders → Type → MetaText) casts whatever you type in clay — a monoline stroke alphabet (lowercase, space, period) fused into one smooth body. Dial Size, stroke Weight and Blend; set Body to melted and the text joins the metaball field, where a keyframed Blend × condenses the word out of a molten mass — or melts it back into one. Renders in Rendre as a MetaText part. Console types: glistenMetaText('word').
- Infill ▦ (Builders → Structure → Infill) fills the body's interior with a space-filling lattice — the way you'd lighten a part in Grasshopper, nTopology or an Adidas 4D midsole, but live. Tick fill the body with a lattice and pick a pattern: the classic triply-periodic minimal surfaces — Gyroid (springy, isotropic), Schwarz-P (open cubic), Diamond (stiff), Neovius (dense) — an Octet truss (a regular strut lattice), Voronoi struts (an organic, irregular open-cell wire — soft-blended junctions), a Strut lattice · 4D (the sheared body-diagonal weave of an Adidas 4D midsole), Voronoi foam · 3D (rounded cell-edge pipes with open windows, a Nervous System print), or a Spinodal · GRF (a smooth isotropic open-cell resin lattice, the Carbon-DLS look).
- Set the Cell size (mm) and the Wall / strut thickness. Core grades the density from the surface inward: 100% is an even fill, 0% hollows the core into a surface cage. Conformal grades the cell size instead — by depth from the surface, not amount: negative packs finer, denser cells near the skin over a coarser open core (nTop's "denser where it matters"), positive densifies the core instead, 0 keeps every cell the same size; it works with every pattern and stacks with Core (which grades strut thickness, not cell size).
- Region grade varies the density across the model along an axis — dense (stiff) at one end, open (soft) at the other, exactly how a printed midsole is tuned. Stretch elongates (or flattens) the cells along an axis for the oriented, directional look of a 4D midsole — it applies to every pattern. A Solid skin keeps a solid outer wall and lattices only the core (the printable shell-and-infill). For Voronoi you also get two toggles — inside (the strut fill) and surface (a Voronoi cell-edge cage with open holes, like a Nervous System print) — and because both are built from the same cells, the interior struts and the surface cage are one coherent structure.
- Everything fuses, weighs and exports as one lattice solid, and the renderer shows exactly what you'll print (raise the Cell size for export-clean walls). Console: window.__setInfill(on,type,cellMm,wall,skinMm), __setInfillCore(c), __setInfillConform(c), __setVorModes(inside,surface), __setInfillGrad(axis,lo,hi).
- Antigranulator ⦂ (Builders → Structure → Antigranulate) scatters a field of soft dimples, bumps or through-holes across the body's skin — a grater's perforation, but un-granulated: every edge is rounded and wet, not sharp (inspired by the Alessi/Zaha "Forma" grater and Yves Béhar / Jawbone surface texture). Pick a Mode (Dimple pits · Bump pimples · Through-hole), set the Cell spacing, the Diameter (feature size as a fraction of spacing), Depth (for dimples/bumps) and a little Dropout for organic irregularity; mixed sizes interleaves big and small holes for the hand-made Alessi look. For real through-holes turn on Shell first (a thin wall to pierce) — on a solid body the hole mode reads as deep pits. It fuses, weighs and exports as one solid. Console: window.__setAntigran(on,mode,cellMm,dia,depthMm,mix,drop).
- ⚬ Rivet Seam (with exactly two forms selected, in the ⌒ Connect… dialog) is FINDINGS — glisten's first derived-node feature: it finds where two forms actually meet and sets a row of rivet-head domes along that seam — when the two forms fully overlap this is a closed ring all the way around, not just a visible arc. Press it, then Set Rivets to detect the seam and place the row; Pitch (mm) spaces them, Head size (mm) sets how big each head reads — independent of Pitch, so tightening the spacing never shrinks the heads into dust, Margin (mm) keeps bare seam at each end, Jitter adds a hand-set wobble to position and size, Blend sets how fused each head reads, and Through also sets a matching rivet on the far side (never seen — a real cold-connection detail). This is regenerate on demand, not live: moving either form does nothing until you press Set Rivets again — closer to a CAD feature's regenerate step than a live simulation. Rivets ride a shared budget (128 per seam), fuse, weigh and export like any other detail, and bake into a solid with ⊕ Merge. Click any placed rivet in the viewport to suppress it or resize it — its position along the seam is remembered, so it stays suppressed or resized even after you regenerate the row. Deleting either parent form removes its seam with a notice. Console: window.__rivetSeams().
- Grapes (Builders → Garden → Grapes) drops a single grape bunch — a tumbling teardrop cluster of jittered berries on its own rachis and pedicels, no vine attached. Dial Berry size, bunch Length / Width / Taper, Scatter (how jittered the berries sit) and Cluster (how fused they read), reroll the Seed for a different bunch, and keyframe Grow (0 = nothing, 1 = the full bunch grown down from the stem) and Wither (0 = plump, 1 = shriveled raisins) for a birth-to-death life cycle. Its sibling Vine (Builders → Garden → Vine) grows a whole grapevine — a woody trunk with drooping shoots and a bunch hanging at every tip — as ordinary Wire canes and Grapes bunches you can move, prune and re-tune.
- ◐ Rendre (top of the toolbar) is the rendering room — a real path tracer. Your sculpt (or an imported OBJ / glTF / Rhino 3DM, or a dropped file) lands auto-scaled on an infinite studio floor; light it by swapping the environment (33 studios — 28 synthesized in-house + 5 Poly Haven CC0, plus the built-in default; drag any .hdr or image onto the canvas to use it — images are expanded to true HDR), with Rotation / Height / Intensity dials; dress it from the materials drawer (614 PBR materials — drag a swatch onto a part, or select-then-click; search speaks both languages: “glass” finds Lucida, “gold” finds Aurum); right-click any part — the floor too — to edit its PBR live (color, metal, rough, glass, coat, sheen, glow). Behind the model you see an infinity surround in the floor's own material (toggle to see the environment image).
- ⬇ Save scene… writes one .glisten with the model AND the whole render setup; ⬆ To Rhino / Blender… hands the scene onward as a GLB — named parts at true scale, every material in Cycles' own PBR vocabulary (so Rhino 8 and Blender re-render it with the same math, not a reinterpretation), the camera, and the lighting setup as a cited reference with its license attached; the dialog states exactly what travels and what stays, and the same caveats ride inside the file. ⬇ Render… saves a PNG up to 4K. One undo history runs through both rooms, ⟲ Clear works in both rooms (in Rendre it clears the stage, imports included), and leaving the render room with an import on stage asks whether to capture it as clay (the same SDF capture as ⤓ Import) or leave it there for rendering.
- Depth of field (Aperture / Focus, in the render dialog) racks a shallow lens blur around the framed model — from a tight macro look on a ring up to a soft background falloff on a bigger, farther-framed piece, since the effective blur scales with how far the camera is standing back; ⊙ Click a point to focus snaps the focus plane to wherever you tap, instead of guessing with the slider.
- ⤓ Decal / logo… projects an image onto one part — a real projection computed in the path trace, not a screen sticker — wrapping it flat (Planar) or fully around a bottle-label axis (Cylindrical); drag Size and Opacity to fit, ⊙ Click a point to place moves it exactly, ⟳ Reproject re-aims it to your current view.
- On any Marmo marble material, ⤓ Seed from a photo… samples a real stone photograph — never a texture of it, a computed argument with it — into ground color, vein color, vein scale and warp; tune the sliders from there.
- A heavy import past this GPU's triangle ceiling used to be declined outright — Lighten heavy imports decimates it to fit, and Add to scene sets a new import down beside what's already on the floor instead of replacing it; when Lighten fires on a fresh scene it keeps a full-resolution copy for renders while the viewport orbits a lighter proxy (⇄ Proxy · Full swaps which one you're looking at).
- ⧉ Export part mattes renders the beauty shot plus one transparent cutout per part, zipped — layers for any 2D editor, no re-render needed to recolor one piece. 🔗 Copy share link… (beside ⬇ Save scene) copies a link that holds the whole render — model, materials, camera, lighting — inside the URL itself; paste it anywhere and opening it rebuilds the exact render, ready to spin. Materials, lighting and the camera in the render room now survive stepping away and coming back, even without an explicit save.
- Save / Load keep your sketch as a re-editable .glisten file (honest JSON inside; saves from the Rendre side carry the full render setup too) (it also autosaves to this browser, so a reload restores it). Undo / Redo — or ⌘Z / ⌘⇧Z — step through your edits.
- ⊕ Merge (appears when two or more forms are selected) collapses them into one captured solid — like merging layers. The parametric pieces become a single form you gumball, boolean, color, weigh and export like any other; the complexity collapses when a composition is locked in. Pick a quality (draft / std / fine), optionally keep the originals (hidden, not deleted), and the merged form saves and survives reload. Undo restores the originals in one step. (Imported and baked-grow captures now survive save/reload too.)
- ⊘ Section (bottom bar, an Advanced tool — flip Section on in Preferences › Advanced) is a view-only cut-away plane: it slices the model on screen so you can see inside it — foam, lattice or a hollow shell wall — without touching the geometry at all. Pick which way the slice faces (X / Y / Z), ⇄ flip which half is kept, and drag Slice to scrub the plane through the model. It never affects weight or any export; turn it off and the model is exactly as it was.
- ⏺ Rec records your whole build — every committed edit is captured into the saved .glisten file, so sharing the file shares how the piece was made, not just how it looks (a student hands in a save; the instructor presses Play and watches the build). Press ⏺ to start (it glows), press again to stop. Whenever a recording is present, a replay bar appears: ▶ Play (replays from the empty stage at 1·2·4×), ⏭ End (jump to the final state), ⎙ Video (a time-lapse to a file), ✕ Clear (remove the recording — Save afterwards to make it permanent). The recording rides inside the file and adds little to its size; it isn't a separate export. (Recording is a desktop workflow; the ⏺ button hides on phones, but you can still watch a replay on any device.)
- ⤓ Import model… brings your own model in — OBJ · STL · glTF/GLB · Rhino 3DM (baked render meshes), the same formats as the render room — as a captured primitive: multi-part files fuse into one clay form (source materials stay in the render room). it's baked into a signed-distance field (the Detail slider sets the resolution — higher is crisper but slower to bake) and dropped into a fresh scene as one form you can fuse, subtract, gumball, shell, and export like any other. It's a frozen capture (movable/boolean-able, not re-shapeable); watertight meshes bake cleanest, and an imported model isn't saved into the .json — re-import after a reload.
- Demo is a guided autopilot — a 30-act tour that drives the real UI with a visible cursor through every tool and mode: sketching and fusing primitives, each gumball handle, Add / Subtract / Intersect, color, the searchable shader library, Mirror (and its X/Y/Z fold axis), the panels drawer, Frame / Grid / Measure, Shell & opening a face into a cup (whole-body and per-part), Bend / Twist (whole-body and per-part), the outliner (rename, the keyable ◉ eyeball, right-click duplicate, typing a value exactly, Undo / Redo), the ◆ Keyframe animator (poses morph, a form added between keys grows in, an eyeballed-off form melts away), a gesture over every export and what its honest manifest carries, Gumbridge and the organic builders — a ⌱ Tendrile drooping between two forms then committed as ordinary clay, a ◈ Spine bead chain twisted into a cylinder cable, a ⌇ Braid of strands wound into a three-ply, a sphere wearing ✦ granules (sixty of them, varied, then banded), and ✧ filigree wire scrolled across a surface — then both at once on one form, beads between the scrolls (the pendant shot) — the ⦂ Antigranulator texturing a body with dimples, bumps, then real through-holes (shelled first), a Lava primitive drifting, melting and stretching into pointy/egg shapes with strings between blobs — the Ring builder, its band then edited like ordinary clay (a bead intersected flush onto it, a carve subtracted) plus a set stone — the shoe-last builder (a parametric shoe last in real mm — size systems, styles, toe shapes, heel/spring — baked to clay, then a primitive fused onto it) — trees grown from seed across species (pear → aspen → fig) and posed by dragging their bones, a figure (joints carry human motion limits) whose wrist gets grabbed, a canine, a seahorse and an octopus, a dyad — a tree and an animal grown together side by side, a creature melted into the clay field, posed while melted, and baked back to clay, two forms collapsed into one captured solid with Merge, Terrain raised and dug, a word cast in MetaText then sized up and reframed (the camera follows scale changes), a short build captured and replayed by the session recorder, and (where WebGPU lives) the ◐ Rendre room: pick a part, dress it in gold, swap the studio. Acts clean up after themselves; it flips Advanced tools on to show them and restores your settings when you press it again to stop.
- Export OBJ meshes the field (consistent outward normals, app units) for handoff to CAD/CAM; Export STL writes the mesh at real millimeters for 3D printing / casting, bundled in a .zip with an honest manifest — metal weight, material cost, the mm bounding box, and a watertight (closed-manifold) check.
- Export GLB writes a colored glTF (real mm) for web / AR / render handoff — it carries your per-form colors as vertex color, and, once a Ring or Flatware builder is active, bakes the metal weight and material into the file's glTF extras too (a plain sculpt's extras carry size and mesh stats honestly — there's no material to estimate, so none is faked). Export FBX writes the colored mesh (real mm) for DCC / game engines — Blender · Maya · Unity · 3ds Max — storing the same figures, under the same Ring/Flatware condition, as the model's user properties (gl_*). Export 3MF writes the modern print interchange (real mm) the same way — metal weight & cost ride along as native 3MF metadata only when a Ring or Flatware builder made the piece.
- Preferences (the ⚙ by the wordmark): turn idle auto-rotate on/off and set its speed — the view drifts after a few seconds without input.
- Outliner (right edge) lists every form — click to select, double-click a name to rename it, and click the ◉ eye to hide a form (it's set aside — removed from the body but kept in the scene; click again to bring it back). ⌘-click (or Ctrl) adds/removes a form; Shift-click selects a range. With several selected, the gumball moves, turns and scales them all together (and Delete removes them all). Works on the canvas too.
- With exactly two forms selected, a ⌒ Connect… button appears — it opens a small dialog with four ways to join them: ⌒ Gumbridge orients a tunable strut between them so two separate forms connect into one fused body (then tune the strut's radius / smoothness like any form). ⌱ Tendrile is the organic cousin: one to eight tendril strands curve between the two forms and fuse into both — with Gravity on they droop on a real catenary (Tension 100 is a straight strut, 0 a full drool); with Gravity off a draggable ⌾ handle pulls the arc anywhere in space. Count adds strands scattered near the anchors, Character makes each wander its own way, Radius (in mm) and Taper shape the tube — all live until you ✓ commit, after which each strand is an ordinary form (gumball-movable, re-editable in the inspector, exportable). When strands pass close to each other they fuse into capillary webs on their own — that's the SDF model doing it, not a parameter.
- ◈ Spine (third in the Connect dialog) places segment forms at regular intervals along the path — spheres make a bead chain, cylinders with Twist make a twisted cable, boxes make vertebrae; Fuse on melts the segments into a continuous rhythm, off leaves a real chain with gaps (the segments are sized never to touch); the whole spine is ONE form afterward, fully re-editable.
- ⌇ Braid (fourth) sends two to six strands winding around the path — two strands make a twisted wire pair, three at Twist 1.5 a classic braid, five spread loose a woven tube; Interlace fuses the strands where they cross, and Spread 0 collapses them to a rope. One form, re-editable, in every export.
- ⚬ Rivet Seam (fifth) is FINDINGS — see its own Help entry above; press Set Rivets in its panel to detect the seam and lay a row of rivet domes along it, on demand.
- With one form selected, a ✦ Decorate… button appears instead, opening a dialog with two surface treatments. ✦ Granule scatters tiny fused beads across that form's surface: Count (up to 200), Radius in real millimeters, size Variation, Pattern (Field · all over, Field · a top or bottom hemisphere, Field · an equatorial band, or Flow · streams along the form's contours), and a Blend that scales with the bead so they always read attached, never melted flat. The beads are packed like real work — never intersecting — and they are part of the form itself: they ride its moves, bend and twist with it, and count in the weight and every export. The technique is Etruscan granulation, the oldest trick in the goldsmith's book: thousands of tiny spheres fused to a surface without solder.
- Its sibling ✧ Filigree traces fine WIRE across the surface instead — strands that run, curl and scroll (Scroll dials wandering vs intentional spirals; Character adds hand wobble), constrained to the form by walking its own distance field, each skinned as wire of a real millimeter gauge and barely fused so it reads as applied, never embedded. Zones and edge behavior (reflect / terminate) shape where the tracery lives; the readout counts total wire length in mm — the goldsmith's consumption figure. Medieval wire tracery, procedurally; like the granules, the wirework is part of the form — it bends with it and counts in the weight and every export.
- Camera — drag empty space to tumble; scroll or pinch to zoom; Frame recenters the view on your design if it drifts off-screen. Measure shows the model's size in mm and lets you click two points on the surface for the distance between them — in real millimeters, the same scale as the Ring & Flatware builders.
- Turntable records a 360° spin of your design to an mp4 — set the duration and frame rate, optionally add a cinematic camera pan or eased (slow→fast→slow) motion; the panels stay out of the video. ● Record renders OFFLINE, one frame at a time — it can take longer than the video's own length on a heavy scene (lots of Lava blobs, a dense lattice), but every frame gets however long it needs, so the result is never stuttery the way trying to capture it live would be. ▶ Preview stays a live, real-time spin (nothing is saved).
- ◆ Keyframe is the animator (an Advanced tool — flip Animator on in Preferences › Advanced): each press captures the whole model (every form's position, rotation, size, shape, color and warps — never the camera). Capture two or more poses — the second key arms playback automatically (the Keyframes toggle in the Turntable box is the opt-out) — and the model morphs through your keys while the camera turns — ▶ Preview plays it live, ● Record saves the video. Forms can come and go between keys: add a form and capture again — on playback it swells into the body at that key (so ◆, add a shape, ◆, add a shape… replays how the thing was built); delete (or eyeball-hide) a form and it melts away. The animation also exports as an Alembic .abc — the Export ABC button opens its own options box (mesh samples + draft/std/fine quality): one animated mesh with a time sample per frame at 24 fps (real millimeters; the topology morphs freely) — any Alembic-aware renderer or animation package plays it directly on the timeline. Playback is non-destructive (your working pose comes back when the turn ends); keys last for the session.
Concordance — glisten ↔ Rhino · Blender · ZBrush
New to 3D, or arriving from a pro tool? Here's how glisten's verbs map to the big packages, so the skills carry both ways. (Search this list — type a tool name like “blender” or a verb like “shell”.)
- Blend × / Smoothness ≈ the smooth-union of an SDF · Blender metaball threshold, or a Boolean with “Smooth” · ZBrush DynaMesh blob fusion / ClayBuildup softness · Rhino has no live equivalent (it's edge fillets after the fact).
- Add · Subtract · Intersect ≈ boolean union · difference · intersection — Rhino BooleanUnion/Difference/Intersection · Blender the Boolean modifier · ZBrush Live Boolean. glisten's are smooth by default (set Blend low for crisp).
- Gumball ≈ Rhino Gumball · Blender the Move/Rotate/Scale gizmo (G/R/S) · ZBrush Gizmo 3D.
- Brush (inflate / deflate) ≈ ZBrush Inflate / Standard · Blender Sculpt mode Inflate / Draw · Rhino none (it isn't a sculpt tool).
- Shell ≈ Rhino Shell / OffsetSrf+cap · Blender the Solidify modifier · ZBrush Panel Loops / Shadowbox shell.
- Thicken (global outset) ≈ Rhino OffsetSrf (solid) · Blender Solidify / Displace · ZBrush Deformation › Inflate.
- Bend · Twist ≈ Rhino Bend / Twist (and Flow along curve) · Blender the Simple Deform modifier · ZBrush Deformation › Bend / Twist.
- Mirror ≈ Rhino Mirror · Blender the Mirror modifier · ZBrush Symmetry (X/Y/Z).
- Infill / Voronoi foam (graded lattice) ≈ Rhino Grasshopper + Intralattice · Blender Geometry Nodes / Voronoi · ZBrush none direct — and the pro lattice tools nTopology and Carbon/adidas-4D. glisten fills + grades it live.
- Wire (freeform tube through points) ≈ Rhino Pipe / Sweep1 along a curve · Blender a Curve with bevel + taper, or the Skin modifier · ZBrush ZSpheres / the Curve Tube brush. glisten's is one tapering SDF curve that fuses like clay.
- Antigranulator (dimple / bump / through-hole field) ≈ Rhino none direct (array + Boolean of holes) · Blender a dot texture driving Displace, or array+boolean · ZBrush Surface Noise / Insert-mesh dot spray. glisten scatters soft-edged perforation live, graded and bimodal.
- FINDINGS / Rivet Seam (rivets auto-placed along a detected boolean seam) ≈ Fusion 360 / SolidWorks a bolt-pattern feature along a selected edge, but those need a real edge to select and re-run on a full history rebuild · Rhino/Blender none direct — a hand-placed array along a curve, redone by hand after any edit. glisten finds the seam itself (no edge to pick) and re-flows it with one button press (Set Rivets), not a full rebuild.
- Section (the ⊘ slice) ≈ Rhino Section / clipping plane · Blender Bisect / the viewport clipping region · ZBrush Slice / Clip brushes (glisten's is view-only — it never cuts the model).
- Merge / Flatten (capture to one solid) ≈ Rhino Join + Mesh · Blender Join (Ctrl+J) / Apply Modifiers / Convert to Mesh · ZBrush Merge SubTools, then DynaMesh.
- Capture / Bake to clay (a grown body → editable solid) ≈ Blender Convert to Mesh · ZBrush DynaMesh / Remesh · Rhino Mesh.
- Grow (tree · figure · creature) ≈ Blender the Sapling add-on / Geometry Nodes · Houdini an L-system node · most tools have no built-in equivalent.
- Rendre (the render room) ≈ Blender Cycles / Eevee · Rhino Render / Cycles · KeyShot. glisten path-traces with HDRI lighting + PBR materials.
- Export STL / GLB / FBX / 3MF (real mm) ≈ every tool exports these — glisten adds an honest weight + watertight manifest. FBX is the DCC / game-engine interchange (Blender · Maya · Unity); OBJ is app-unit, for general CAD.
- ◆ Keyframe / Turntable ≈ Blender the timeline + a turntable render · ZBrush Movie / Turntable · Rhino none built-in.
- ⤓ Decal / logo (a real 3D projection, not a screen sticker) ≈ ZBrush Spotlight (image-projected onto the sculpt) · Blender a Decal/Stencil texture, or an Image Texture projected from a camera empty · Rhino none direct (a mapped texture on a render mesh).
- ⇄ Proxy · Full (work light, render full) ≈ ZBrush a ghosted/lower-density SubTool level · Blender a Decimate modifier shown in the viewport, full mesh at render · Rhino a simplified display mesh over the real NURBS.
- ⧉ Export part mattes (beauty + one alpha cutout per part) ≈ Blender/Cycles Cryptomatte or per-object render passes · KeyShot per-material alpha channels · Rhino none built-in (a render-layer workaround).
A short history of metaballs
The idea is older than most modeling tools. In 1982 Jim Blinn, visualizing molecules at JPL, described surfaces as a sum of soft density fields — his "blobby model." Where the fields overlapped, the surfaces bulged together. Touch two and they became one.
A few years later (1983–85) a group at Osaka University — Nishimura, Hirai, and colleagues — formalized the same notion for animation and named it metaballs (メタボール). In 1986 the Wyvill brothers and Craig McPheeters refined the field functions into "soft objects" with finite, well-behaved falloff.
The missing piece was turning a field back into a surface you could render or print. Marching Cubes (Lorensen & Cline, 1987) and Bloomenthal's implicit-surface polygonizers solved that — sample the field on a grid, find where it crosses zero, stitch triangles. glisten's OBJ export is a descendant of exactly this step (it uses marching tetrahedra, after Doi & Koide, 1991).
Through the 1990s metaballs became the look of liquid metal and mercury (the T-1000 lineage), a demoscene staple, and a stock feature of the big animation packages of the day. Digital sculpting tools later took the organic, topology-free spirit in their own direction.
The modern thread is signed distance fields (SDFs). Instead of summing densities you store distance-to-surface and combine shapes with a smooth minimum — popularized for real-time use by Inigo Quilez and the Shadertoy era, and raymarched directly on the GPU. SDF booleans give clean smooth unions and subtractions for free, which is why a whole new generation of clay-like, topology-free modelers is built on them. glisten sits squarely in that thread: every form is an SDF, fused with a smooth-min, raymarched live.
The fuller theory-wing version lives at Classicery's Canon: Kajiya's rendering equation (track 13 — the embedded Rendre room's own path tracer implements this integral) and Lindenmayer's L-systems (canon5, track 3 — GROW is a real L-system).
Credits & license
Made by Phil Renato and Claude (Anthropic), 2026 — part of ILCA. Non-commercial research software — your models and renders are yours (see LICENSE, DISCLAIMER & NOTICES alongside the app). Installable on iPad — Add to Home Screen for a fullscreen app that works offline.
Full LICENSE / DISCLAIMER / NOTICES text — embedded here so it travels with this one file, even if renato.design ever disappears
LICENSE.txt
GLISTEN — LICENSE
===========================================================
Copyright (c) 2026 Phil Renato. All rights reserved.
NON-COMMERCIAL RESEARCH SOFTWARE. glisten is published as a
research artifact — an investigation into browser-native
SDF modeling and path-traced rendering — not as a commercial
product. It is made available for use, study, and teaching
at renato.design free of charge, without accounts, telemetry,
or payment of any kind.
WHAT YOU MAY DO
- Use glisten in the browser for any purpose, including in
your own commercial design work: models, scenes, exports,
and renders YOU make with glisten are YOURS, entirely.
- Study it. The source is one readable HTML file by design.
WHAT THIS LICENSE DOES NOT GRANT
- Redistribution, rehosting, mirroring, or resale of the
application or its bundled material/environment libraries,
in whole or in part, outside renato.design.
- Use of the glisten or Rendre names to imply endorsement.
THIRD-PARTY COMPONENTS + ASSET PROVENANCE
- See NOTICES.txt for the full third-party license texts
(three.js MIT, rhino3dm MIT, IBM Plex Mono OFL), algorithm
attributions (AgX et al.), and the provenance statement for
the Rendre material + environment libraries.
NO WARRANTY — see DISCLAIMER.txt. Provided AS IS; no fitness
for any purpose is promised; estimates are estimates.
DISCLAIMER.txt
GLISTEN — DISCLAIMER
===========================================================
glisten is NON-COMMERCIAL RESEARCH SOFTWARE — a research
artifact published for study and teaching, not a commercial
product. It is provided AS IS, without warranty of any kind,
express or implied. Use it at your own risk.
HONEST NUMBERS, STILL ESTIMATES. Metal weights, melt values,
and material costs shown in the Ring and Flatware builders
are computed from the actual modeled volume and editable
commodity prices, but they are ESTIMATES for sketching and
teaching — not quotes. They exclude labor, stones (priced
separately where shown), finishing, and margin. Verify with
your caster/supplier before committing money or metal.
EXPORTS. STL/3MF/GLB/OBJ/ABC exports carry an honest
manifest where the format allows; the watertight check is
reported truthfully (including known non-manifold junction
counts). Always run your slicer's own checks before
printing or casting.
RENDRE MODE. Path-traced renders are a faithful physical
simulation of the parametric materials and environments,
but they are previsualization — not color-managed proofs.
The display transform is AgX; final print/production color
decisions need a managed pipeline.
BROWSER REQUIREMENTS. The modeler needs WebGL2. Rendre mode
needs WebGPU (Safari 26+ on Mac, current Chrome/Edge).
Rhino .3dm import reads baked render meshes only — render
or shade your model once in Rhino before exporting.
NOTICES.txt
GLISTEN — THIRD-PARTY NOTICES + ASSET PROVENANCE
===========================================================
glisten is NON-COMMERCIAL RESEARCH SOFTWARE published as a
research artifact by Phil Renato (see LICENSE.txt +
DISCLAIMER.txt). This file lists what it uses and where the
bundled assets came from.
RUNTIME LIBRARIES (loaded from CDN, not redistributed here)
-----------------------------------------------------------
three.js — MIT License
Copyright (c) 2010-2026 three.js authors
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or
sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
rhino3dm / openNURBS — MIT License
Copyright (c) 2018-2026 Robert McNeel & Associates
(Same MIT terms as above. Loaded on demand, only when a
Rhino .3dm file is imported. "Rhino" and "Rhinoceros" are
trademarks of Robert McNeel & Associates; glisten is not
affiliated with or endorsed by McNeel — the name is used only
to identify file-format compatibility.)
VENDORED (bundled in vendor/, same-origin — not CDN-loaded)
-----------------------------------------------------------
mp4-muxer — MIT License, © Vanilagy (github.com/Vanilagy/mp4-muxer)
Used by the Rendre room's Film/Shots video export (WebCodecs H.264
frames muxed into a QuickTime-ready .mp4). Bundled at
vendor/mp4-muxer/mp4-muxer.js as the UMD global Mp4Muxer.
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or
sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
FONT
-----------------------------------------------------------
IBM Plex Mono — SIL Open Font License 1.1, © IBM. Served by
Google Fonts at runtime; not redistributed in this file.
CODE PROVENANCE (algorithms re-implemented from literature)
-----------------------------------------------------------
- AgX display transform: Troy Sobotka's AgX (the Blender 4.x
default look); the minimal polynomial fit follows the widely
shared approximation published by Benjamin Wrensch (iolite
engine blog). Reimplemented in WGSL for this app.
- GGX microfacet model: Walter et al. 2007; Smith masking;
Schlick Fresnel approximation; exact dielectric Fresnel.
- Environment importance sampling: piecewise-constant 2D
distribution after Pharr/Jakob/Humphreys, PBRT.
- BVH: binned SAH construction after Wald 2007.
- Orthonormal basis: Duff et al. 2017 (Pixar).
- PCG hash RNG: O'Neill, PCG family.
- Path tracing: Kajiya 1986, the rendering equation.
- Marching tetrahedra polygonization: after Doi & Koide 1991.
- Mesh fairing: Taubin 1995 (λ|μ smoothing without shrinkage,
with Newton projection back to the true SDF surface).
- Smooth-min SDF combines, and the analytic curve/segment
distance functions (the quadratic-bezier tube and capsule
behind the Tendrile / Spine / Braid organic builders):
popularized by Inigo Quilez.
- L-systems (the GROW branching builder): the parallel
rewriting grammar of Aristid Lindenmayer 1968; 3-D
turtle interpretation after Prusinkiewicz & Lindenmayer,
"The Algorithmic Beauty of Plants" 1990. The stochastic
grammar + tropism model and the GLSL/JS code are glisten's.
- Skeletal posing: linear-blend skinning of the grown bodies
(standard skeleton-subspace deformation).
- The Alembic/Ogawa writer and all UI code: original to glisten.
These are methods from published literature; the WGSL/GLSL/JS
implementations here were written for glisten.
BUNDLED ASSET LIBRARIES (Rendre mode)
-----------------------------------------------------------
The parametric MATERIAL LIBRARY (577 entries) consists of
scalar shading parameters (color, metalness, roughness, IOR,
transmission, coat, sheen, emission) extracted from the
material library authored for Rendre (Phil Renato's research
renderer), with Rendre's own re-authored names and taxonomy
(Lucida, Aurum, Argent, Latten, Heartwood, Lithic, …).
Texture-driven and procedural node-group materials were
deliberately EXCLUDED from the port — only parameter values
travel, no third-party textures, node graphs, or .blend data.
The ENVIRONMENT LIBRARY was REBUILT 2026-06-06 so every
shipped studio has pinned provenance. ONE TELLING, used
everywhere: 33 fetched studios in the drawer = 28
synthesized originals + 5 Poly Haven CC0 photographic sets,
plus the embedded default studio (also synthesized). Two
buckets, no exceptions:
SYNTHESIZED / ORIGINAL (28 in the drawer, + the embedded
default + the modeler's reflective studio): procedurally
generated, original work, made for glisten by Phil Renato +
Claude with rendre_assets/tools/make_envs.py (soft-panel /
pinhole / tube / ring / gradient-wash synthesis in
direction space).
annulus-low-contrast · backwash-cinnabar · backwash-sodium
· backwash-three-pinholes · backwash-tyrian ·
backwash-verdigris · cage-room · coved · five-light-studio
· floorlight-screen · four-light-studio ·
four-square-mirrored · full-wash-tyrian · low-contrast ·
paneled · plush-gray · rendre-studio · rimlit-three-point
· soft-back · soft-light · studio-panel ·
three-light-studio · three-point-high-contrast ·
three-point-two-pinholes · top-and-bottom-center-pinhole ·
tubes · underlit-square · vertical-bands · plus the
embedded "Rendre Studio" default and the modeler's
reflective studio image.
PHOTOGRAPHIC, CC0 — Poly Haven (5 in the drawer): fetched
2026-06-06 from polyhaven.com (CC0 1.0 — no attribution
required; given with thanks; disused-warehouse re-encoded
same day to clean a malformed upstream header — pixel data
identical, see _provenance_cc0.json). Per-file source log
ships in
rendre_assets/env/_provenance_cc0.json.
ballroom <- polyhaven.com/a/dancing_hall
photo-studio-sienna <- polyhaven.com/a/brown_photostudio_02
empty-cell <- polyhaven.com/a/small_empty_room_3
snow-wood <- polyhaven.com/a/snowy_forest
disused-warehouse <- polyhaven.com/a/empty_warehouse_01
RASTER, CC BY-SA (1, modeler chrome only): the SEATL chrome
environment is "Space Needle 360° Panorama", Wikimedia
Commons, CC BY-SA —
https://commons.wikimedia.org/wiki/File:Space_Needle_360_Panorama.jpg
(also credited in the app's Help panel).
The environment set previously distributed with Rendre
(studio-light rig images of unconfirmed authorship) was
RETIRED from glisten on 2026-06-06 and is no longer shipped.
TRADEMARKS
-----------------------------------------------------------
Glisten™ and RENDRE™ are marks of Phil Renato. Ideas and
source may travel; the names may not. All other trademarks
are the property of their respective owners. Mentions of
third-party applications (e.g. Rhino, Blender) identify
file-format compatibility only and imply no affiliation or
endorsement.
CONTACT
-----------------------------------------------------------
Phil Renato · renato.design · philrenato@gmail.com