Animating the Folk: A Blender-to-Game Sprite Pipeline

One of the most time-consuming parts of building Oakborn has been creating the folk—those chunky little settlers who wander around your village carrying stones, praying at the Heart Oak, and generally being cozy. In this post, I’ll walk through the animation pipeline I’ve built to make this manageable as a solo dev.

The Challenge: 8 Directions × Many Animations #

Oakborn uses pre-rendered 2D sprites for its 3D isometric look. Each folk needs to be viewed from 8 directions (N, NE, E, SE, S, SW, W, NW), and each direction needs multiple animations: idle, walk, carry, eat, pray, and more.

The math gets scary fast. Even a simple 24-frame walk cycle across 8 directions is 192 individual frames. Add in the other animations and you’re looking at thousands of sprites per character.

I needed a pipeline that could handle this without losing my mind.

The Setup: One Character, Eight Cameras #

In Blender, I set up 8 cameras arranged in a circle around the character, each pointing inward at 45° increments. The character always faces “south” in the scene—the cameras do the work of capturing every angle.

This means I animate once and render eight times. The cameras are fixed, so I never have to think about rotation during animation work.

NLA Stacking: The Real Time-Saver #

Here’s where Blender’s Non-Linear Animation (NLA) system earns its keep. Instead of creating separate animations for “walk,” “walk while carrying stone,” and “walk while carrying bucket,” I build animations as stackable layers:

• Base layer: A subtle breathing idle that runs constantly
• Movement layer: Walk cycle (or nothing, for stationary actions)
• Action layer: The actual task—carrying, eating, praying

So “walking while carrying a stone” is actually three animations playing simultaneously: breathe + walk + carry. The NLA system blends them together.

The eating animation above doesn’t use the walk layer at all—it’s just breathe + eat. Praying and idle work the same way. This modularity means I can mix and match without re-animating everything from scratch.

The Render Script #

A Python script drives the actual export:

1. Iterate through each animation combination I need
2. For each combination, configure the NLA stack
3. Render from all 8 cameras
4. Output directly to the game’s asset folder

The whole process runs overnight for a new character. I wake up to a folder full of sprite sheets ready to drop into Godot.

Design Choices #

The folk went through a lot of iteration during early concepting before landing on their current look: chunky proportions, simple faces, and clothing that reads clearly at small sizes. The Celtic-inspired hoods and trim help sell the setting without requiring high detail.

I deliberately kept the color palette soft and slightly desaturated. These characters need to feel like they belong in a peaceful world, not demand attention. When a folk carries a stone across your screen, it should feel like watching something gentle happen—not an action scene.

Building Worlds With Code #

Twenty years ago, I wrote Image_3D—a 3D rendering library in PHP. It was absurd, impractical, and exactly the kind of project that happens when you love both programming and visual creation in equal measure.

That tension never went away. I’ve always been drawn to the intersection of code and art: the satisfaction of a well-architected system and the joy of seeing something beautiful emerge from it. Game development sits right at that intersection, which is why I kept coming back to it despite false starts with C#+FNA, Rust+Vulkan, and Unity.

Blender finally clicked for me the way those other tools never did. It’s keyboard-driven. It rewards learning the shortcuts. The NLA system I described above isn’t hiding behind a friendly GUI—it’s a proper composable system that behaves predictably once you understand it. Same with Godot on the engine side: I use almost none of the visual editor. It’s code all the way down, with the editor as a preview tool.

The folk animation pipeline isn’t glamorous, but it represents something I’ve been searching for since Image_3D: a way to build worlds where the programming is the art and the art is the programming. No fighting the tools. No context-switching between “creative mode” and “engineering mode.”

NLA stacking turns an exponential problem into something additive. That’s satisfying in the same way a good abstraction is satisfying—it makes the complex feel simple. And when I watch a little folk carry a stone across the screen, breathing gently, path-finding around obstacles, I’m not just seeing an animation. I’m seeing twenty years of searching for the right way to build worlds with code.

Oakborn: Sacred Settlement is a cozy Celtic village builder currently in development. Follow along on the Dev Blog to see more behind-the-scenes posts like this one.