HOLLOWCUT Devlog
Second Spring · How the art is made · 3 Nov 2026 · updated 5 Nov

From a picture to the valley — Second Spring's asset pipeline

Most models made for Second Spring start as a concept picture: Claude writes the prompt and FLUX.2 klein, running on Cloudflare Workers AI, draws it. From there it takes one of two routes into the game. Creatures and keepers go through Tripo, an image-to-3D service that turns the picture into a textured model, and Claude cleans it up and rigs it in Blender. Everything else (buildings, props, decor, the Old Tree, the Harrow and the cosmetic looks) is built from Python code in Blender, with no Tripo step at all. Both routes end in the same scripts, the same checks and the same side-by-side comparison, and land in the Godot game. Now a newer route has become our main pick: Rigforge, our own tool that turns a concept or a prompt into a rigged, animated model on our own GPU. Tripo is no longer the main route; the creatures in the game so far came through it. (Some village scenery comes from bought asset sets; this page is about the models made for the game.)

← Back to the Second Spring devlog

The pipeline

Who does what, from the first prompt to the valley. Every step on the 3D side is a script, so a model can be rebuilt from scratch at any time.

  1. Claude

    Brief

    Writes the prompt from the design and the house rules: not an Earth animal, a clay-and-felt look, no gold (gold belongs to the Harrow), one figure on a plain grey background in a three-quarter view. Two or three earlier creature sheets go along as references so the newcomer fits the cast.

  2. FLUX.2 klein (Cloudflare)

    Concept

    Two takes per idea, laid out on one labelled sheet.

  3. Claude

    Pick

    Claude picks the concept that fits best and notes what to keep: the ears, the colours, the face. For buildings and decor the concept is often skipped or kept as a target to check against.

Rigforge, our main pick creatures, keepers and every other character

  1. Rigforge (ours)

    Picture to model

    TRELLIS, running on our own GPU inside Rigforge, turns the clean A-pose concept into a 3D mesh, and the concept art is projected back on for sharp details.

  2. Rigforge (ours)

    Auto-rig

    UniRig rigs it. Beast mode recognises four-legged, six-legged, winged and tailed bodies and rigs every limb.

  3. Rigforge (ours)Claude

    Auto-fix

    Claude checks the rig: it adds cape bones, keeps armour and heads rigid and catches parts that wobble when they should not. Fixes can also be asked for in plain words in the chat panel, and every change can be undone.

  4. Rigforge (ours)

    Animate

    Clips come from a library of about 2,900, and creatures get their own walk, idle and flap cycles. A prompt becomes a rigged model in about three minutes.

Before Rigforge, creatures went through Tripo: one picture in, a textured model out, then cleaned up, rigged on one shared skeleton and coloured by Blender scripts. The creatures in the game so far came that way; the comparisons and examples below show that route.

Built in Blender code buildings, props, decor, trees, landmarks, the Harrow and every cosmetic look

  1. ClaudeBlender, scripted

    A script builds it

    Claude writes a Python script for Blender that builds the model from shapes: turned profiles for a teapot, soft blobs on bones for a creature, rigid pieces for eyes, horns and crystals, cut panels for stone.

  2. Blender, scripted

    Colour as data

    Colour lives in the model itself, from one shared palette, and materials are only kinds of surface (fur, jelly, shell, glass, glow), so seasons and looks can recolour anything.

  3. ClaudeBlender, scripted

    Render and compare

    The model is rendered and checked side by side against its concept. Change a number, run the script again, get the new model: nothing is edited by hand, so nothing gets lost between rounds.

The two routes meet on the creatures too: their clothes and hats are built in code on top of the image-to-3D bodies. A script measures each body and grows the clothes out of its skin, so they move with it.

  1. Rigforge (ours)Blender, scriptedClaude

    Clips

    Every creature needs idle with blinks, walk (or hop, or slide for a slug), happy, look, sleep and hit. Rigforge brings them from its library and cycles; for the Tripo and code-built creatures they are written once and scaled by each species.

  2. Blender, scripted

    Phone copy

    Smaller textures packed into the model, about a megabyte for a Tripo creature, so the download stays small.

  3. Godot

    Checks

    A strip per clip, then real shots in the valley at game distance: fur, glow, blinks, the walk and the seasons.

  4. ClaudeGodot

    Compare

    Concept, model and in-game shot side by side on one sheet. The written rules aim for two rounds, where the first creatures took five.

In the game

Why two routes

Image-to-3D for faces and fur

The first creatures were all built in code, and each took four to six rounds before they were right. A creature lives on its face, its felt and its glossy eyes, and the image-to-3D route carries those over from the concept almost as drawn. The creatures in the game today are Tripo remakes. New ones now go through Rigforge, which does the same on our own GPU and rigs and animates them as well.

Code for everything that has to fit

Homes sit on hexes, trees change with the seasons, the Old Tree wakes in stages and every look recolours. A model that is a script can do all of that: its parts are named, its colours are data and a new variant is a few lines. It also stays small, which matters on a phone.

What we tried for image-to-3D

Four options have turned our concept pictures into models so far: three services and, now, our own tool. None of them is wrong; the choice comes down to time against cost.

Works, for humanoids

Meshy

It gives good models, but mostly for humanoid figures. Its rigging is built around a human skeleton, and most of our creatures are not shaped like people: four legs, no neck, a tail or a slug's body. Rigging those afterwards proved hard.

Great, but too heavy to run locally

Trellis

It worked really well, and running it ourselves gave far more control over every step. But it ran on our own development machine, and even a 4090 graphics card hit its limit. While a model was being made, the rest of the development work on that machine stood still.

Our previous pick

Tripo

It was our pick for the first creatures, through its API for multi-part models. The models needed touch-ups once the animations are hooked up, for creatures and humanoids alike: welding seams, fencing the weights so a limb doesn't drag the body, fitting blinking lids and taking off the shine. Those steps became scripts that every creature made so far runs through.

Our pick now

Rigforge

Our own tool, and now our main pick, taking over from Tripo. It turns a concept or a prompt into a rigged, animated model on our own GPU, in about three minutes for a creature, with the fixes built in. The creatures made so far came through Tripo. More about Rigforge below, or read the Rigforge devlog.

Next: remote GPU power

With Rigforge running on our own graphics card, our own machine is now the bottleneck. Making and processing models, rendering checks and baking all compete for the same graphics card, and the rest of the development work waits while they run. We want to explore hooking up remote GPU power, so the heavy steps can run elsewhere and in parallel, and the pipeline speeds up without blocking the work in front of it.

Our main pick now

Rigforge: our own image-to-rigged-model tool

Rigging creatures for Second Spring by hand was slow, so we built Rigforge. It’s a desktop-style app that takes a concept image or text prompt and gives back an animated, game-ready model, all running locally on our own GPU. It has taken over from Tripo as our main pick for creatures; Blender code still builds everything else. Rigforge has its own devlog, with every step, test and dead end.

Rigforge: the model library, the 3D viewport and the tabs for rig, animation, fixes and the assistant.

The app

Rigforge started as a few scripts. We turned it into an editor that feels like a real app. It has a model library, a 3D viewport, and tabs for skeleton, skin weights, fixes and animation. You can drag joints, paint which parts follow which bones, and scrub through clips.

  1. The frondling’s skeleton in X-ray, with the bone list.
  2. The stiltwalker’s skin weights, painted per bone.
  3. The puffwing on the Fix tab: Auto-fix, parts and selection tools.

The pipeline

  1. FLUX makes a clean A-pose concept image.
  2. TRELLIS turns it into a 3D mesh, and the concept art is projected back on for sharp details.
  3. UniRig auto-rigs it. Beast mode recognises four-legged, six-legged, winged and tailed bodies and rigs every limb.
  4. Auto-fix uses Claude to check the rig. It adds cape bones, keeps armour and heads rigid, and catches parts that wobble when they shouldn’t. Every change can be undone.
  1. Auto-fix results: each fix with what it measured before and after.
  2. The puffwing’s flap, before: the head squashes as the wings beat. After: the head holds still.

AI assistant

A chat panel lets you say things like “make the chest plate rigid”. The AI works out which part you mean and plans the fix.

The assistant finds the chest plate and plans the fix, ready to apply or discard.

Animation

You can search about 2,900 Mixamo and Quaternius clips, and creatures also get their own walk, idle and flap cycles.

  1. A walk loop from the clip library, mid-stride.
  2. Beast-mode rigs and their own walk cycles, frame by frame.

First test: six Second Spring creatures

We ran the rootbeast, stiltwalker, puffwing, lanternslug, spinnet and frondling through the pipeline. A prompt becomes a rigged GLB in about 3 minutes.

Rootbeast, stiltwalker and puffwing: from concept to mesh, rig and pose.
Lanternslug, spinnet and frondling: from concept to mesh, rig and pose.

Code against Tripo

The same concept, built twice. The middle column is the first version, sculpted in Blender from Python code; the right one is the Tripo remake that replaced it. Code gets the colours and the idea, but faces, felt and shapes drift away from the picture. Tripo keeps them.

Rootbeast

The code version kept the green but turned into a smooth bean with a stubby saddle. Tripo keeps the felt, the bark back with its mushrooms and the happy face.

  1. Concept
  2. Built in code
  3. Tripo remake

Shellmole

In code it became a seal with a single hood. Tripo brings back the overlapping shell plates, the tendril whiskers and the digging claws.

  1. Concept
  2. Built in code
  3. Tripo remake

Spinnet

The code version is a tidy orange toy. Tripo gets the fuzzy face and the cream belly; the yarn ball was taken out of the picture first, like every prop, because props fuse into the hands.

  1. Concept
  2. Built in code
  3. Tripo remake

Lanternslug

The closest match in code, but its face is two dots and a line. Tripo carries over the blushing cheeks, the plump body and the lantern bulb, which still glows in the game.

  1. Concept
  2. Built in code
  3. Tripo remake

Bruno

Our dachshund. Built in code he was a soft brown sausage; Tripo gives him the long low body, the droopy eyes and the floppy ears of the concept.

  1. Concept
  2. Built in code
  3. Tripo remake
Rigforge showcase

Rigforge: TRELLIS against TRELLIS.2

Two Second Spring creatures, each made in Rigforge from the same concept by both models on one 16 GB graphics card. The renders use the same camera and light and show the textured mesh after clean-up and paint, before rigging.

Frondling

TRELLIS.2 is the better model here. Its fronds are crisp where TRELLIS's are blotchy with a dark tear, and it makes one clean flower on each tail where TRELLIS doubles one. Its weak spot is the right eye, which has a visible ring around it.

  • TRELLIS 89 s, 19k triangles, 4.5 MB
  • TRELLIS.2 250 s, 9.5 GiB peak VRAM, 69k triangles, 10.7 MB
  1. Concept (front view)
  2. TRELLIS
  3. TRELLIS.2

Puffwing

Neither model handles this much fur: both break it into shards and both lose the tail. TRELLIS.2's wings are cleaner, but its body is shardier, with a pale patch of the concept's ground shadow under the feet (from a background cut that has since been replaced). It ran out of memory at full resolution and fell back to half.

  • TRELLIS 141 s, 35k triangles, 5.3 MB
  • TRELLIS.2 598 s including the failed attempt, 7.1 GiB at 512, 84k triangles, 9.8 MB
  1. Concept (front view)
  2. TRELLIS
  3. TRELLIS.2

So far it's a mixed result. TRELLIS.2 gives sharper detail on clean shapes like the frondling's fronds, but on a furry creature like the puffwing its surface comes out rougher than TRELLIS's. It also takes about three times as long and makes bigger files. We're working on getting smoother surfaces out of it; until then we keep both in Rigforge. The heavy runs are also why our own machine has become the bottleneck. More tests, including side and back pictures as input, are in the Rigforge devlog.

Four examples

Real files from the game: the concepts as they were picked, the models as the game loads them (rendered on a plain floor for this page) and screenshots from test builds. Tap an image to see it larger.

Image-to-3D (Tripo)

The frondling

The first creature of the valley, remade from its concept through the image-to-3D route. The fronds, the felt and the big glossy eyes come straight from the picture.

  1. Concept (FLUX.2 klein)
  2. The model, shape only
  3. Textured and rigged
  4. In the valley
Image-to-3D (Tripo)

The Harrow pup

One concept, both routes. The first pup was built in code from cut crystal panels; the remake through the image-to-3D route keeps the same idea with the marble and the face of the picture.

  1. Concept (FLUX.2 klein)
  2. First version, built in code
  3. Tripo remake
  4. In the valley at night
Built in code

The Old Tree

The heart of the valley is built in code: the cloud of a crown, the arms, the sleeping face and the ring of turf it stands in. It changes as it wakes, which is easy when the model is a script.

  1. Concept (FLUX.2 klein)
  2. Built in code, shape only
  3. With its colours
  4. In the village
Built in code

The teapot cottage

An optional look for a home. The belly, lid and spout are turned profiles, the door, window and forget-me-nots are placed on the surface, and the steam curls out of the spout.

  1. Concept (FLUX.2 klein)
  2. Built in code, shape only
  3. With its colours
  4. Its picture in the game

Concept pictures are AI-made (FLUX.2 klein) and marked as such. Claude writes the prompts and the Blender scripts, picks the concepts and checks every model against them. Back to the devlog.