VOXIFY voxelizes meshes while aiming to preserve color and other material maps such as roughness and metallic. The workflow captures UVs, then creates attributes so the voxel result can pull data from the original textures. If you want a drinking game: Take a shot every time we write the word Voxel, and consider your current life choices, when you play drinking games at 8AM in the morning on a Monday, when this news comes out.

The tool targets stylised voxel art renders, LEGO-style renders, game environments, and abstract motion graphics. It also calls itself non-destructive, meaning the setup stays editable as a modifier rather than forcing an immediate apply.

Material support comes with a big practical caveat. The modifier cannot work with simple colour materials or multi-material objects unless you first bake all materials and colours into a single texture, then use that texture for colour transfer. The same rule applies to other maps. VOXIFY works well with 3D-scanned assets, where the look already lives in texture maps.

Import, scale, then touch the voxel size slider

VOXIFY loads into a scene through Blender’s append workflow. You append a VOXIFY collection from the downloaded file, which loads an empty mesh with the Geometry Nodes modifier. Duplicate that empty mesh per asset, then place the duplicate into the working collection for that shot.

Before you voxelize anything, two basics: apply transforms and keep object scale sensible. Applying scale uses the standard apply transform workflow and voxel size behaves like a real world control, so a tiny prop and a skyscraper should not share the same voxel size value. A very large object expects a larger voxel size value, otherwise performance and results fall apart.

Once the base setup behaves, voxel size becomes the main artistic lever. Smaller values create denser voxels. Larger values create chunkier results. That is where VOXIFY tries to feel like a production-friendly knob instead of a one-click filter.

Viewport choices and custom instances

VOXIFY includes controls for how the result displays in the viewport versus final render, switching the viewport representation to a point cloud for optimization, while keeping a voxel look for render. The modifier also supports custom voxel shapes. Instead of instancing cubes, you can instance a user supplied object as the voxel unit. Transparent areas get special handling. The setup includes masking transparent parts by enabling a mask with texture option and feeding an opacity map, so voxels do not fill areas that would never render.

Pruning, carving, and not paying for invisible cubes

Voxelization loves to create internal structure you never see, and VOXIFY exposes controls to deal with that. For transparent textures, the prune and mask controls help stop voxels from spawning in cutout regions. For solid objects, there is an option to remove internal voxels, reducing geometry that would sit inside the mesh and never contribute to the image. That internal removal matters both for render performance and for downstream conversion to a static mesh.

VOXIFY also brings pruning – carving out a more accurate outer shape. The prune section offers two carving methods: raycast and distance. Raycast is more accurate, while distance can help keep more vxoels where you need them. Tolerance controls how aggressively that carving behaves, and it often starts near the same value as voxel size.

Static mesh output, plus the part where topology bites back

VOXIFY includes a generate static mesh option, because internal volume matters here: without volume, the generated static mesh can end up with an unwanted inner wall. Keeping internal structure can provide the volume needed so the static mesh output produces a single outer shell rather than double walls.

Even with volume, a few stray points can remain visible. The cleanup uses a mesh selection workflow to isolate and delete unwanted vertices after generation. For leafy assets like a fern or a tree canopy, the volume approach can introduce unwanted voxels under thin surfaces. A distance tolerance control helps define how much thickness to assume, using a value that matches the thickest meaningful part of the object, such as a trunk when talking about trees (or strangely morphed elephants). Just give the algorithm enough thickness to produce a clean mesh while avoiding filling every thin sheet with junk geometry.

Fixed animation options for rigs and deformers

VOXIFY includes a fixed animation feature designed to avoid revoxelizing the mesh every frame. There is a contrast on an animated object: one mode voxelizes each frame, tracking the deforming shape. Fixed animation instead holds the shape of each voxel as it was first generated, while following the animation. There is a limitation when the animated object expands compared to the source mesh used for voxelization, which can produce gaps between cubes. A static mesh generation option can help close that visual gap, but at the cost of changing the nature of the result.

Fixed animation is especially suitable for animated characters, where deformation usually does not involve large expansion or compression. In practice, that makes it a tool for rigs where you want temporal stability, fewer recalculations, and less flicker from per-frame resampling.

Assembly animation, because everything must explode nicely now

VOXIFY includes assembly animation controls that animate voxels from a starting state into place. An animation factor control with keyframing it from 0 at the start frame to 1 at the end frame. It also flags a practical performance issue: changing the assembly value can be slow because the node graph recomputes upstream operations.

To speed that up, the tutorial demonstrates baking parts of the setup once you stop changing voxelization parameters like voxel size and maps. The idea is to freeze the heavy part of the graph so assembly animation updates closer to real time during iteration.

The assembly system includes a speed scale control that changes how fast each voxel moves from start to destination, affecting how much motion blur you might get. It also includes randomization options to avoid a layer by layer build, plus a distribution control that projects the assembled object onto a disc and uses radius and location to change where assembly starts.

Included is a progressive assembly option that tries to assemble the connected structure first, such as building the trunk before floating branches, or whatever the morphed elephant is made of. It has settings like iterations and selection controls, and the tutorial demonstrates debugging by inspecting selection masks in the viewport using standard node debugging interaction.

All of this remains a reminder that a modifier can feel like magic, until a shot needs determinism. Treat VOXIFY like any new procedural tool: test it on throwaway scenes and verify output stability before you use it in production.

Versions, requirements, storefront reality

VOXIFY requires Blender 5.1 or higher. Superhive has three tiers: Personal Use at 8 USD, Commercial Use at 25 USD, and Studio at 49 USD. The Studio tier is “team use” for up to 5 seats. Superhive also lists render engines used as Cycles and Eevee.

https://superhivemarket.com/products/voxify–mesh-to-voxel-modifier

https://www.artstation.com/marketplace/p/o5rnD/voxify-blender-mesh-to-voxel-modifier

The post VOXIFY turns Blender Meshes to Voxels and animates first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

The pitch: stop keyframing the math

Physics-style motion looks simple right up until you try to animate it by hand. You want an object to arc, spin, fall, and land with a believable rhythm. Then you end up nudging curves, correcting timing, and trying to keep the rotation from looking like it came from a different universe than the translation.

NodeMonkey built Inertia around the idea that artists should steer intent, not equations. The tool targets Blender 5.1 and is a Geometry Nodes-powered add-on that handles the math and generates trajectories, rotations, and gravity-based motion. The claim is workflow first: fewer clicks, fewer editors, and less time spent hand-authoring the same ballistic arc for the hundredth time.

A free version is available, alongside a paid edition. Pricing is shown as €0+ so you can name your own price, and pay what you think is fair.

Three systems, three kinds of pain relief

The core of Inertia is three built-in systems, each aimed at a familiar animation task that tends to spiral into curve surgery.

Projectile Inertia focuses on launched objects. The tool includes an auto-aim function intended to help consistently hit targets. Think arrows, thrown props, or anything that needs to land where art direction says it must land, while still pretending physics had a say.

Orbital Inertia targets celestial mechanics. If you ever tried to keyframe orbital paths and keep speed and curvature consistent, you already know why a dedicated system exists for it.

Curve Inertia keeps objects locked to paths with gravity-like behavior. The examples called out include jet fighters and roller coasters, which is another way of saying motion that must follow a path but still feel like weight and momentum exist.

All three systems sit inside Blender 5.1 and lean on Geometry Nodes rather than external solvers or custom simulation frameworks. About a third of the way in, here is the small gotcha you should keep in mind: any tool that generates motion procedurally can hide complexity behind friendly UI. That is great until you need to debug. Test early, test with your real scene scale, and test with the constraints you actually ship, not the demo that came in the download.

Viewport prediction: the part you will actually use

The most practical feature is a real-time predictive curve drawn directly in the viewport. The idea is simple: see the path before you press Play. That means you can adjust aim and motion direction with visual feedback instead of running the timeline like a slot machine.

The same preview concept applies to both projectile arcs and orbital paths, displayed as a live line in the viewport. It is a small change that can save a lot of micro-iterations, especially when you work under direction that changes its mind three times before lunch.

The Sources also claim you do not need to know Geometry Nodes to use the tool. Instead, you adjust sliders for Gravity, Friction, and Speed without opening the node editor. That is the classic adoption strategy for node-based power features: give artists a clean control surface first, let the curious dig deeper later.

Practical notes for production brains

If you plan to use Inertia for shots, treat it like any new procedural motion system. Run a few stress tests with your real frame ranges and scene scale. Check whether the motion remains stable when you change FPS, time-warp, or hand off to another artist who needs to tweak the result without breaking the rig. Verify how the generated motion behaves when you render on the farm or upgrade Blender mid-project.

https://nodemonkey.gumroad.com/l/inertia

The post Inertia brings clicky physics to Blender first appeared on DIGITAL PRODUCTION and was written by Bela Beier.