Skip to content
Keenan Crane@keenanisalive · Oct 9, 2026

With everyone busily using LLMs + Blender/Three.js to make 3D models, I thought I'd try a different geometric…

31 tweets4 min read♥ 2.5Koriginal

Summary

A developer used Claude with visual feedback to create a 3D dragon model represented as 27KB of GLSL code defining an implicit surface, rather than a mesh or NeRF. The process required 25 hours of AI assistance and 27 rounds of human feedback, demonstrating both the potential and limitations of LLMs for procedural 3D modeling compared to faster diffusion-based approaches.

Summarized by ThreadOut AI from the full thread. May miss nuance — read the thread below.

  1. #1

    With everyone busily using LLMs + Blender/Three.js to make 3D models, I thought I'd try a different geometric representation. This dragon isn't a mesh, NeRF, 3DGS, or video model: it's 27kb of GLSL code (generated via LLM), defining a closed-form implicit surface. 🧵 [1/n]

  2. #2

    Before you get too excited: “image-to-implicit” isn't (yet) fully automatic—nor could I have ever done without the latest LLMs. It took 25 hours (!) of Astra model/tool calls, over 27 rounds of human feedback. [2/n]

  3. #3

    In fact, I'm pretty sure the only person in the world who can build models like this by hand is @iquilezles. My AI-assisted process borrows (and outright steals) from his work. In that spirit, I dub the model “Inigo the Dragon”: cs.cmu.edu/~kmcrane/Proje… Sorry @iquilezles! [3/n]

  4. #4

    Also: this is just an experiment! If you really need to make an organic 3D model from images, diffusion-based mesh generators (Meshy, Tripo, etc.) are vastly faster, cheaper, and better quality—and fully automatic! E.g., these meshes took ~3 minutes, at about 50¢ each. [4/n]

  5. #5

    Not to mention the output implicit surface is extremely expensive to visualize. Even after writing a custom Metal renderer (to keep my machine from crashing…) the video above took about 45 minutes to render. I ended up meshing the damn thing just to inspect/critique it. [5/n]

  6. #6

    So, with the warnings & admonitions out of the way, how did I do it? The first step was to generate front/side reference images (via Nano Banana). This was by far the easiest part—speaking again to the power of diffusion models (instead of LLMs…) for dense visual content. [6/n]

  7. #7

    Now comes the hard part: how do we construct a 3D model that agrees with two 2D projections (that may not even be consistent with each other)? This is an ill-posed problem: many distinct combinations of (geometry, materials, illumination, camera) produce the same image. [7/n]

  8. #8

    To get any kind of reasonable answer, we need some kind of regularizer or prior. In this approach, one prior on geometry is: “the object is made by blending together basic geometric primitives,” like boxes, ellipsoids, etc. [8/n]

  9. #9

    The idea of “blobby modeling” goes way back. You can trace its roots at least to Maxwell's 1873 treatise, where he draws equipotential lines for charged particles—effectively defining nicely-curved geometry from just a few degrees of freedom: charge centers & magnitudes. [9/n]

  10. #10

    ~100 years later, still motivated by visualizing atoms, Jim Blinn picked up on this idea to visualize molecules in “A Generalization of Algebraic Surface Drawing.” But he also suggested that you could riff on this idea to build more general models, like a blobby person. [10/n]

  11. #11
  12. #12

    Since then, smart folks built up richer blobby models and “metaballs” (Nishimura, Wyvill, Witkin, …) and implicit visualization algorithms we now take for granted, like Lorensen & Cline's marching cubes and Hart's sphere tracing. @rms80 can correct me on history here. [11/n]

  13. #13

    Like Maxwell's atoms, these “blobjects” are a very compact representation of shape: a few parameters (radii, lengths, blend weights, …) describe a rather complex surface. You might say they “compress” shape nicely. See longer rambling post here: [12/n]

    Keenan Crane@keenanisalive · Sep 19, 2026

    For 3D learning, the “Bitter Lesson” doesn’t properly respect Kolmogorov complexity. The colloquial version of the bitter lesson is that, in a nutshell, just scaling up data and compute always beats problem-specific modeling (note that this is not actually what Sutton said; more on that later). But look at the current situation with LLMs and agents generating 3D content: the really impressive examples depend on configuring an API, language, or software package (Three.js, OpenSCAD, Blender, etc.). Each representation impacts the description size for a given object—and for the classes of object that can be faithfully represented via one of these procedural descriptions, the encoding is vastly more efficient than an explicit description (points, splats, polygons, etc.) or even an implicit description (SDF, NeRF, etc.). Moreover, the smaller you can make the procedural description, the better the LLM works: it has to predict fewer tokens to describe the same object, because each token does a better job of compressing geometric information. E.g., the words “unit sphere” are far more compact than a list of points or a collection of voxels. So, in the procedural setting, building models for predicting shape becomes an exercise in bounding Kolmogorov complexity: what’s the smallest “program” I can use to describe a given object? (Or more precisely: which language minimizes description length *and* the entropy of the description, for a model trained on that language.) That’s why current tools lean on carefully crafted abstractions (again, Blender, OpenSCAD, Three.js, etc.), for which many examples are available. Astra doesn’t run off and build you a giant neural network, hoping that the “right representation” will somehow be learned deep within the network weights. None of this, by the way, contradicts what Rich Sutton actually said: the input/output encoding matters, even if the rest is just scaling up search and learning. And the reason we see examples in Three.js and not a more esoteric language is that there is a large corpus of examples to learn from. But the idea that the network will just “learn the best representation” by adjusting its weights is a misguided fiction. Instead, it really seems like we are entering an era of “code as geometry” counterposed to WorldLabs’ “geometry as code”, where design of domain-specific languages is a key task. (And of course, search and learning will inevitably play a role in this design…) Computer Graphics also plays a central role, because it’s the mechanism for decompressing the procedural description into an explicit representation (building a cylinder, tessellating a curve, etc.). That’s the tool calling part of the agentic process. And the better these graphics algorithms get, the more effective the language becomes. People are worried about the death of Computer Vision—but it seems Graphics is coming back from the grave. 🧟‍♂️ (And, might I add, that differential geometry is a very expressive language that few are taking advantage of in this setting. 😉)

  14. #14

    At the same time, their irregular, tree like structure makes them harder to learn than, say, a signed distance function (SDF) sampled on a regular grid—which is a lot more like learning an image. Not to mention that there isn't much data! Very few artists model this way. [13/n]

  15. #15

    But hey, (i) LLMs model statistics of more “tree-like” data, and (ii) LLMs (really, VLMs) are getting much better at 3D spatial intelligence. In some sense this is just "Blender primitives,” but for smooth organic shapes rather than hard-surface models. Worth a try, right? [14/n]

  16. #16

    Coming back to our dragon example, here's the very first prompt I gave Astra, plus this reference image: 𝙼𝚊𝚔𝚎 𝚊 𝟹𝙳 𝚖𝚘𝚍𝚎𝚕 𝚋𝚊𝚜𝚎𝚍 𝚘𝚗 𝚝𝚑𝚒𝚜 𝚒𝚖𝚊𝚐𝚎, 𝚛𝚎𝚙𝚛𝚎𝚜𝚎𝚗𝚝𝚎𝚍 𝚊𝚜 𝚊 𝚙𝚛𝚘𝚌𝚎𝚍𝚞𝚛𝚊𝚕 𝚜𝚒𝚐𝚗𝚎𝚍 𝚍𝚒𝚜𝚝𝚊𝚗𝚌𝚎 𝚏𝚞𝚗𝚌𝚝𝚒𝚘𝚗 𝚊 𝚕𝚊 𝙸𝚗𝚒𝚐𝚘 𝚀𝚞𝚒𝚕𝚎𝚣. 𝙱𝚞𝚒𝚕𝚍 𝚊 𝚕𝚒𝚋𝚛𝚊𝚛𝚢 𝚘𝚏 𝚋𝚊𝚜𝚒𝚌 𝚜𝚑𝚊𝚙𝚎𝚜 𝚊𝚗𝚍 𝚜𝚑𝚊𝚙𝚎 𝚌𝚘𝚖𝚋𝚒𝚗𝚊𝚝𝚒𝚘𝚗 𝚘𝚙𝚎𝚛𝚊𝚝𝚒𝚘𝚗𝚜, 𝚒𝚗 𝚝𝚑𝚎 𝚜𝚙𝚒𝚛𝚒𝚝 𝚘𝚏 𝙸𝚗𝚒𝚐𝚘'𝚜 𝚙𝚊𝚐𝚎 𝚊𝚝 𝚑𝚝𝚝𝚙𝚜://𝚒𝚚𝚞𝚒𝚕𝚎𝚣𝚕𝚎𝚜.𝚘𝚛𝚐/𝚊𝚛𝚝𝚒𝚌𝚕𝚎𝚜/𝚍𝚒𝚜𝚝𝚏𝚞𝚗𝚌𝚝𝚒𝚘𝚗𝚜/ 𝚙𝚕𝚞𝚜 𝚊𝚗𝚢𝚝𝚑𝚒𝚗𝚐 𝚎𝚕𝚜𝚎 𝚢𝚘𝚞 𝚗𝚎𝚎𝚍. 𝚄𝚜𝚎 𝚠𝚛𝚒𝚝𝚝𝚎𝚗 𝚊𝚗𝚍 𝚟𝚒𝚍𝚎𝚘 𝚝𝚞𝚝𝚘𝚛𝚒𝚊𝚕𝚜 𝚏𝚛𝚘𝚖 𝙸𝚗𝚒𝚐𝚘 𝚊𝚗𝚍 𝚘𝚝𝚑𝚎𝚛𝚜 𝚒𝚗 𝚑𝚒𝚜 𝚜𝚙𝚑𝚎𝚛𝚎 𝚝𝚘 𝚞𝚗𝚍𝚎𝚛𝚜𝚝𝚊𝚗𝚍 𝚋𝚎𝚜𝚝 𝚙𝚛𝚊𝚌𝚝𝚒𝚌𝚎𝚜 𝚏𝚘𝚛 𝚖𝚘𝚍𝚎𝚕𝚒𝚗𝚐 𝚠𝚒𝚝𝚑 𝚂𝙳𝙵𝚜. 𝚄𝚜𝚎 𝚟𝚒𝚜𝚞𝚊𝚕 𝚏𝚎𝚎𝚍𝚋𝚊𝚌𝚔 𝚝𝚘 𝚌𝚛𝚒𝚝𝚒𝚚𝚞𝚎 𝚊𝚗𝚍 𝚛𝚎𝚏𝚒𝚗𝚎 𝚝𝚑𝚎 𝚖𝚘𝚍𝚎𝚕, 𝚏𝚛𝚘𝚖 𝚊 𝙶𝙻𝚂𝙻/𝚂𝚑𝚊𝚍𝚎𝚛𝚃𝚘𝚢 𝚜𝚝𝚢𝚕𝚎 𝚛𝚎𝚗𝚍𝚎𝚛𝚎𝚛 (𝚊𝚕𝚜𝚘 𝚞𝚜𝚒𝚗𝚐 𝚊𝚕𝚕 𝚝𝚑𝚎 𝚝𝚛𝚒𝚌𝚔𝚜 𝚊𝚗𝚍 𝚝𝚎𝚌𝚑𝚗𝚒𝚚𝚞𝚎𝚜 𝚏𝚛𝚘𝚖 𝙸𝚗𝚒𝚐𝚘 𝚊𝚗𝚍 𝚏𝚛𝚒𝚎𝚗𝚍𝚜, 𝚕𝚒𝚔𝚎 𝚜𝚙𝚑𝚎𝚛𝚎 𝚝𝚛𝚊𝚌𝚒𝚗𝚐 𝚊𝚗𝚍 𝚒𝚝𝚜 𝚖𝚊𝚗𝚢 𝚎𝚡𝚝𝚎𝚗𝚜𝚒𝚘𝚗𝚜). 𝚆𝚘𝚛𝚔 𝚌𝚘𝚊𝚛𝚜𝚎 𝚝𝚘 𝚏𝚒𝚗𝚎, 𝚏𝚒𝚛𝚜𝚝 𝚎𝚜𝚝𝚊𝚋𝚕𝚒𝚜𝚑𝚒𝚗𝚐 𝚝𝚑𝚎 𝚋𝚞𝚕𝚔 𝚜𝚑𝚊𝚙𝚎, 𝚝𝚑𝚎𝚗 𝚙𝚛𝚘𝚐𝚛𝚎𝚜𝚜𝚒𝚟𝚎𝚕𝚢 𝚊𝚍𝚍𝚒𝚗𝚐 𝚖𝚘𝚛𝚎 𝚊𝚗𝚍 𝚖𝚘𝚛𝚎 𝚍𝚎𝚝𝚊𝚒𝚕. 𝙼𝚊𝚔𝚎 𝚒𝚝 𝚙𝚘𝚜𝚜𝚒𝚋𝚕𝚎 𝚝𝚘 𝚜𝚎𝚕𝚎𝚌𝚝 𝚍𝚒𝚏𝚏𝚎𝚛𝚎𝚗𝚝 𝚕𝚎𝚟𝚎𝚕𝚜 𝚘𝚏 𝚍𝚎𝚝𝚊𝚒𝚕 𝚒𝚗 𝚝𝚑𝚎 𝚏𝚒𝚗𝚊𝚕 𝚜𝚑𝚊𝚍𝚎𝚛. 𝚃𝚑𝚎 𝚖𝚘𝚍𝚎𝚕 𝚜𝚑𝚘𝚞𝚕𝚍 𝚒𝚗𝚌𝚕𝚞𝚍𝚎 𝚌𝚘𝚕𝚘𝚛 𝚊𝚗𝚍 𝚌𝚘𝚕𝚘𝚛 𝚋𝚕𝚎𝚗𝚍𝚒𝚗𝚐, 𝚗𝚘𝚝 𝚓𝚞𝚜𝚝 𝚐𝚎𝚘𝚖𝚎𝚝𝚛𝚢. 𝙵𝚘𝚛 𝚏𝚒𝚗𝚊𝚕, 𝚜𝚖𝚊𝚕𝚕𝚎𝚜𝚝-𝚜𝚌𝚊𝚕𝚎 𝚝𝚎𝚡𝚝𝚞𝚛𝚊𝚕 𝚍𝚎𝚝𝚊𝚒𝚕𝚜, 𝚜𝚎𝚎 𝚒𝚏 𝚢𝚘𝚞 𝚌𝚊𝚗 𝚌𝚘𝚖𝚎 𝚞𝚙 𝚠𝚒𝚝𝚑 𝚜𝚘𝚖𝚎 𝚌𝚕𝚎𝚟𝚎𝚛 𝚛𝚎𝚙𝚎𝚊𝚝𝚒𝚗𝚐 𝚙𝚛𝚘𝚌𝚎𝚍𝚞𝚛𝚊𝚕 𝚜𝚘𝚕𝚒𝚍 𝚝𝚎𝚡𝚝𝚞𝚛𝚎 (𝚙𝚎𝚛𝚑𝚊𝚙𝚜 𝚠𝚒𝚝𝚑 𝚜𝚘𝚖𝚎 𝚐𝚎𝚗𝚝𝚕𝚎 𝚠𝚊𝚛𝚙𝚒𝚗𝚐 𝚝𝚘 𝚊𝚍𝚊𝚙𝚝 𝚝𝚘 𝚝𝚑𝚎 𝚜𝚑𝚊𝚙𝚎) 𝚛𝚊𝚝𝚑𝚎𝚛 𝚝𝚑𝚊𝚗 𝚖𝚘𝚍𝚎𝚕𝚒𝚗𝚐 𝚎𝚊𝚌𝚑 𝚒𝚗𝚍𝚒𝚟𝚒𝚍𝚞𝚊𝚕 𝚎𝚕𝚎𝚖𝚎𝚗𝚝 𝚊𝚜 𝚒𝚝𝚜 𝚘𝚠𝚗 𝚙𝚛𝚒𝚖𝚒𝚝𝚒𝚟𝚎. 𝚃𝚑𝚎 𝚏𝚒𝚗𝚊𝚕 𝚛𝚎𝚗𝚍𝚎𝚛 𝚜𝚑𝚘𝚞𝚕𝚍 𝚞𝚜𝚎 𝚑𝚒𝚐𝚑-𝚚𝚞𝚊𝚕𝚒𝚝𝚢 𝚒𝚕𝚕𝚞𝚖𝚒𝚗𝚊𝚝𝚒𝚘𝚗 𝚊𝚗𝚍 𝚖𝚊𝚝𝚎𝚛𝚒𝚊𝚕𝚜, 𝚞𝚜𝚒𝚗𝚐 𝚙𝚑𝚢𝚜𝚒𝚌𝚊𝚕𝚕𝚢-𝚋𝚊𝚜𝚎𝚍 𝚒𝚕𝚕𝚞𝚖𝚒𝚗𝚊𝚝𝚒𝚘𝚗 𝚊𝚗𝚍 𝚜𝚑𝚊𝚍𝚒𝚗𝚐 𝚊𝚙𝚙𝚛𝚘𝚡𝚒𝚖𝚊𝚝𝚒𝚘𝚗𝚜 𝚊𝚍𝚟𝚘𝚌𝚊𝚝𝚎𝚍 𝚏𝚘𝚛 𝚋𝚢 𝙸𝚗𝚒𝚐𝚘 𝚊𝚗𝚍 𝚏𝚛𝚒𝚎𝚗𝚍𝚜, 𝚏𝚘𝚛 𝚊 𝚏𝚒𝚗𝚊𝚕 𝚋𝚎𝚊𝚞𝚝𝚢 𝚙𝚊𝚜𝚜. 𝙱𝚞𝚝 𝚢𝚘𝚞 𝚖𝚊𝚢 𝚏𝚒𝚗𝚍 𝚒𝚝 𝚏𝚊𝚜𝚝𝚎𝚛 𝚝𝚘 𝚒𝚝𝚎𝚛𝚊𝚝𝚎 𝚞𝚜𝚒𝚗𝚐 𝚊 𝚜𝚒𝚖𝚙𝚕𝚎𝚛, 𝚙𝚞𝚛𝚎𝚕𝚢 𝚕𝚘𝚌𝚊𝚕 𝚜𝚑𝚊𝚍𝚒𝚗𝚐 𝚖𝚘𝚍𝚎𝚕. 𝙰𝚜 𝚘𝚞𝚝𝚙𝚞𝚝, 𝚙𝚛𝚘𝚟𝚒𝚍𝚎: - 𝙰 𝚌𝚕𝚎𝚊𝚗 𝚕𝚒𝚋𝚛𝚊𝚛𝚢 𝚘𝚏 𝚋𝚊𝚜𝚒𝚌 𝚜𝚑𝚊𝚙𝚎, 𝚌𝚘𝚕𝚘𝚛, 𝚊𝚗𝚍 𝚜𝚑𝚊𝚙𝚎 𝚌𝚘𝚖𝚋𝚒𝚗𝚊𝚝𝚒𝚘𝚗 𝚏𝚞𝚗𝚌𝚝𝚒𝚘𝚗𝚜 - 𝚃𝚑𝚎 𝚙𝚛𝚘𝚌𝚎𝚍𝚞𝚛𝚊𝚕 𝚖𝚘𝚍𝚎𝚕 (𝚊𝚜 𝚌𝚘𝚍𝚎), 𝚎𝚡𝚙𝚛𝚎𝚜𝚜𝚎𝚍 𝚠𝚒𝚝𝚑 𝚛𝚎𝚜𝚙𝚎𝚌𝚝 𝚝𝚘 𝚝𝚑𝚒𝚜 𝚌𝚕𝚎𝚊𝚗 𝚕𝚒𝚋𝚛𝚊𝚛𝚢 - 𝙰 𝚋𝚎𝚊𝚞𝚝𝚢 𝚛𝚎𝚗𝚍𝚎𝚛 𝚘𝚏 𝚝𝚑𝚎 𝚏𝚒𝚗𝚊𝚕 𝚖𝚘𝚍𝚎𝚕 - 𝚃𝚑𝚎 𝚛𝚎𝚗𝚍𝚎𝚛𝚒𝚗𝚐 𝚌𝚘𝚍𝚎 𝚞𝚜𝚎𝚍 𝚝𝚘 𝚐𝚎𝚗𝚎𝚛𝚊𝚝𝚎 𝚌𝚛𝚒𝚝𝚒𝚚𝚞𝚎 𝚒𝚖𝚊𝚐𝚎𝚜 𝙱𝚊𝚜𝚒𝚌𝚊𝚕𝚕𝚢, 𝚒𝚗 𝚊𝚍𝚍𝚒𝚝𝚒𝚘𝚗 𝚝𝚘 𝚝𝚑𝚎 𝚏𝚒𝚗𝚊𝚕 𝚖𝚘𝚍𝚎𝚕, 𝚙𝚛𝚘𝚟𝚒𝚍𝚎 𝚊𝚗𝚢 𝚔𝚒𝚗𝚍 𝚘𝚏 𝚑𝚊𝚛𝚗𝚎𝚜𝚜 𝚢𝚘𝚞 𝚠𝚛𝚘𝚝𝚎 𝚒𝚗 𝚘𝚛𝚍𝚎𝚛 𝚝𝚘 𝚐𝚎𝚗𝚎𝚛𝚊𝚝𝚎 𝚝𝚑𝚒𝚜 𝚖𝚘𝚍𝚎𝚕, 𝚜𝚘 𝚝𝚑𝚊𝚝 𝚠𝚎 𝚍𝚘𝚗'𝚝 𝚑𝚊𝚟𝚎 𝚝𝚘 𝚜𝚝𝚊𝚛𝚝 𝚏𝚛𝚘𝚖 𝚜𝚌𝚛𝚊𝚝𝚌𝚑 𝚒𝚗 𝚝𝚑𝚎 𝚏𝚞𝚝𝚞𝚛𝚎. [15/n]

  17. #17

    I then held my breath for 45 minutes and 47 seconds, and got this, uh, beautiful result. Amazing that Astra can do this at all. But also falls way, way short of what we got in 3 minutes with a diffusion model. But, I pushed on anyway to see how far I could take it. [16/n]

  18. #18

    My next attempt took the “true believer” approach to AI: just tell the model, “believe in yourself!” I also gave it more stuff to rip off, including some of Inigo's code and transcripts. This definitely improved things, but we were still far off the goal. [17/n]

  19. #19

    The “do better!” approach stalled out pretty quickly, so I switched to giving human feedback. My experience with even the best VLMs is that their understanding of images is uneven at best, especially when you get into high-end 3D, or image artifacts. [18/n]

  20. #20
  21. #21

    In this process, it often felt like Astra sporadically had some even bigger blind spots. Like: how did you accept a regression as big as making that tail stick straight out? Who knows. 🤷 [19/n]

  22. #22

    Moreover, it's unclear where the training data for nuanced visual tasks, like subtle artistic adjustments, or visual bug fixes, is supposed to magically come from in the future. Certainly not in ImageNet; it's also not well-represented in YouTube, etc. Good luck, @OpenAI. [20/n]

  23. #23

    Anyway, over the next few days, I would: - Provide some feedback to Astra - Check in on my phone minutes/hours later - Rinse & repeat Mostly with human feedback, but I'd occasionally let "Astra loose," having it self-critique with an “objective” Astra VLM (no history). [21/n]

  24. #24

    Progress was slow but… slow. In the end, the creative process felt similar to many other tools, just at a different level of abstraction. And evolved as I got a better feel for the tools, developed techniques, etc. Not so different from paint, clay, or 3D modeling. [22/n]

  25. #25

    There were also points where it definitely felt like tweaking the model by hand would be way faster than trying to spell out low-level tweaks in text prompts. Plenty of space for people to build richer interfaces around these models. No reason it must be text-based. [23/n]

  26. #26

    I should also confess that at some point… I cheated! I gave it screenshots of a model produced by an image-to-3D diffusion model. I think there's something deep here: these models provide extremely good priors, and it seems really stupid not to use them. [24/n]

  27. #27

    I mean, I get the multimodal hypothesis, the bitter lesson, blah blah blah. But when the difference in efficiency is that extreme, you have to take off your machine learning hat for a moment, and put on your computer science hat. [25/n]

  28. #28

    Anyway, this has been an intriguing journey down the road of geometry respresentations, statistical models, and artistic process. In case you missed the model files, they're here (code, images, meshes, and all): cs.cmu.edu/~kmcrane/Proje… [26/n]

  29. #29

    You can also view and interact with the shader live here, on ShaderToy: shadertoy.com/view/sXtXR7 ⚠️ Warning that it may crash your browser! I just caught some flak from @iquilezles for this on ShaderToy… maybe a human-machine collab will help fix it. 👨🏻‍🦲❤️🤖 [27/n]

  30. #30

    @iquilezles Forgot to share this diagram (generated from the code), which gives a sense of how the model is broken down into different levels of detail, per my request in the initial prompt. Coarse-to-fine strategies are crucial for all sorts of spatial problems. Likely helps VLMs as well.

  31. #31

    @iquilezles Another omission: Even my reference image was a low-key cheat: I had good intuition that rounder shapes and simpler materials might reasonably be modeled via closed-form implicits. A more realistic dragon would not have worked. (Yet diffusion-based mesh still models nail it…)