For those who don’t know the tool: Flying Bugs Generator is a Blender setup built with Geometry Nodes, delivered as ready-to-use assets for the Asset Browser so you can drag generators into shots and animate swarms or curve flights.

You know that feeling when you need bugs for a shot and nature refuses to cooperate? Some people just knock on the neighbor’s door and instantly receive a swarm and an entire insect census, because apparently soap is optional in that household (We are lucky, yes. Our joy knows no bounds, as well as the pest control dude on speed dial). For everyone else, there is Flying Bugs Generator in Blender, a controllable swarm machine that keeps the chaos procedural and the kitchen hygienic.

Ryan King Art has a more pipeline-friendly option: Flying Bugs Generator, a Blender tool built with Geometry Nodes for animating swarms of flying insects. The setup focuses on controllable motion and quick iteration. You adjust parameters on modifier properties to change how many bugs you get, how far they spread from a center, how noise affects the motion, plus scale, speed, rotation speed, and options for animating along a curve.

Ten bugs enter the shot, none demand attention

The pack includes ten bug types: flies, honey bees, locusts, gnats, moths, bumble bees, wasps, mosquitos, fireflies, and termites. Each type supports three movement modes. Swarm mode flies bugs around the surface of a mesh, and you can edit that mesh to steer the path.

Along Curve mode follows a curve and adds manual animation control over a set number of bugs, with editable curve handles to direct motion. Never Ending mode also uses a curve, but generates a continuous stream along it.

In other words, it is built for the common scenarios: a localized cloud of insects you art-direct with geometry, a guided flight path you key for timing, and an endless emitter you can loop without hand-placing a thousand wingbeats. You’ll probably see which one you need to remaster the 90’s cinematic masterpiece “The Mummy”.

Asset Browser delivery, aka less setup, more anmiation

All generator objects come pre-configured as assets in Blender and are intended to be used through the Asset Browser. The workflow described is to set up an asset library in user preferences, then drag and drop a generator into a scene. This turns a node setup into something a team can reuse consistently. You get a predictable entry point in the scene, and you can treat the generator like any other asset instead of a one-off node graph someone forgot to name. Sship the complexity once, expose the controls that artists actually touch, and keep the scene file readable on a Monday morning.

Pricing and the boring part you still need to know

The suggested price is $15 here: Superhive (formerly Blender Market), which is far less than the effort and materials to breed the bugs yourself, get cameras, and an animal handler to teach them to fly along the chosen paths.

Also available through Fab.com.

As always, test new tools and innovations before you bet a deadline on them, especially anything procedural that can multiply geometry, instances, and render time faster than you can say “why is the viewport at two FPS”.

https://ryankingart.gumroad.com/l/bug
https://ryankingart.gumroad.com/

The post These are the Bugs You Were Looking For (in Blender) first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

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.

For those who don’t know the tool: Stylized Tree Asset Generator is a Blender Geometry Nodes based tree builder for stylized environments, with Eevee focused shading and toolsets that also run in Cycles.

Pines, at last, for people who hate needles

Stylized Tree Asset Generator now includes a dedicated Stylized Pine Tree Asset Generator as part of its 2.0 update. The new pine toolset comes with new assets, textures, shaders, and materials, and keeps the same general workflow as the original tree generator to stay consistent.

The update also targets speed and housekeeping. Version 2.0 replaces deprecated nodes from Blender 4.2, optimizes UV storage, and cleans up and optimizes the Geometry Nodes setup. It also adds directional control to the wind feature and ships an updated user guide.

If you were already using the original generator for quick background dressing, the pine addition is welcome because it expands the library beyond broadleaf shapes and lets you cover the classic stylized use case: conifers in midground forests, mountain ranges, and gamey dioramas without modeling individual branches by hand.

Painterly Trees for Blender: ShapeScape Studio Blooms

What it actually builds and how far you can push it

The core promise is a Geometry Nodes setup that lets you shape trees quickly, then dial resolution up or down depending on what you need. You can go from low poly silhouettes to more detailed results by adjusting resolution and density inputs, keeping a tighter leash on polygon count.

The tool generates automatic UVs so you can bake textures. That makes it easier to take a procedural look, commit it, and move on, whether you need a static asset for a library or a one-off hero tree that still has to survive export.

It also supports using your own mesh to shape the leaves. That is the escape hatch for people who like procedural trunks but want art-directed foliage shapes, or who already have leaf cards and want the generator to place them. There is also a Random Generator input intended to produce infinite variations with similar characteristics. In practice, that is the difference between a forest and a cloning accident, especially when you need dozens of trees that read as a family but do not look copied.

Some of the shading work targets Eevee. The product notes say the shading was designed in Eevee and may not work as intended in Cycles by default, while the rest of the tools work in both render engines. So if your pipeline leans on Cycles, expect to tweak materials rather than treating the lookdev as drop-in.

Painterly Garden: 200+ Ghibli-Style Foliage Assets for Blender

Presets, shaders, normals, and the parts you will actually notice

Stylized Tree Asset Generator includes preset textures and materials aimed at getting you to a usable look quickly. It lists 10 leaf texture presets, 16 trunk presets, and 12 hand-painted procedural leaf textures. Those sit alongside procedural textures that remain adjustable, so you can keep the preset as a starting point rather than a locked style.

For shading, it includes a custom toon shader for the trunk and two shading groups for leaves, one designed for simpler use and one offering deeper controls. It also includes four sets of custom normals meant to help you land the shading style you want and to keep shading stable when you animate wind and use the scatter tool.

The update also keeps the wind feature in the toolbox, and adds direction control. That matters because wind without direction tends to look like your trees are trying to shake off a bad rig. Directional control lets you line up motion with camera moves or scene beats, instead of getting random flapping.

This is also where teh usual production advice applies: test it in a real shot, with your real render settings, before you roll it into a template file and wonder why the farm hates you.

Compatibility and versions

The newest versions of the tool are made for Blender 4.2 and newer, while still including older versions of the tools as far back as Blender 3.3. If your studio sits on a locked version for a show, that matters, because it suggests you can still run a supported variant without forcing an upgrade mid-production. The 2.0 update specifically calls out node maintenance aligned with Blender 4.2, including replacing deprecated nodes and cleaning up the node graphs. That kind of update tends to be invisible until it is missing, at which point your node tree becomes an archeological dig.

🌲 V2.0 Update 🌲
Huge update of my Stylized Tree Asset Generator, you can now make Stylized Pine Trees!
And it's 25% off right now on @superhivemarket https://t.co/noDDhYwniC https://t.co/AlV1OYbOUM pic.twitter.com/tWZSN5v4fK

— Rei (@Reipart_) May 6, 2026

Pricing and the temporary deal situation

Pricing is tiered on Superhive Market. A Standard License is listed at $12.50 and includes textures, shading nodes, geometry nodes, and tools. An Asset Pack Standard License is listed at $16.50 and adds the full asset pack. A Commercial Use option is listed at $42 and includes the asset pack while allowing commercial use.

If you are evaluating it for production, the practical move is to grab it, build a handful of trees that match your show style, bake what you need, and push them through your actual export and render path. Then decide whether it becomes a staple, a one-off, or a neat toy that lives in a personal toolkit.

https://superhivemarket.com/products/stylized-tree-generator

The post If you yearn for the pines, go Blender first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the Project: Blender Studio ships open movie assets, training, and production tooling built around the Blender DCC, including add-ons and pipeline workflows for animation and rendering, as well as battletesting the whole Blender Pipeline.

The film release, minus the fluff

Singularity is out as a short film in 4K HDR, framed as a painterly space adventure directed by Andy Goralczyk. It follows a small creature whose home gets destroyed by an ominous black hole, pushing it toward a group of luminous creatures and a mysterious celestial being.

The release matters less for the plot and more for what it packages with the movie. The singularity includes downloads of ALL production assets, frames, and high quality encodes under a Creative Commons Attribution license. That makes it usable as real-world test data for storage, conform, and review, not just a nice watch on a big screen.

Painterly look, procedural muscle

The production leans into a watercolor inspired style led by art director Vivien Lulkowski, mixing hand-crafted textures and brush strokes with generative effects. That combination aims for an organic look in the creatures while keeping the black hole graphic and geometric.

On the tool side, the film was created with the most recent in-development version of the DCC, and the team expanded the Brushstroke Tools library with new painterly assets. They also used Geometry Nodes to develop procedural “crowd animation” systems (The quotation marks are about the Crowds, not the system), which makes the project a handy reference if you want to compare node-based instancing logic against your own setups or caching strategy.

If you want a fast internal taxonomy for the kind of work this project touches, it sits squarely in animation and practical stylization, with enough proceduralism to interest anyone who keeps one eye on Geometry Nodes changes.

Story development, and what you can actually access

A dedicated story development “article “log” exists by director Andy Goralczyk, but the page requires a login to read the full content – you can support Blender Studio with a subscription for access to training.

HDR is the real production test here

The 4K HDR part is not a sticker, it is a workflow commitment. HDR delivery usually forces decisions about monitoring, transforms, and what you consider the master, especially when you also need an SDR version that holds up. The projectfocuses on watching it on a large screen, but for post teams the more interesting angle is that it gives you real files to validate ingest, grading, and export choices with.

If you are sanity-checking what HDR usually means in standards terms, ITU-R BT.2100 defines image parameter values for HDR television used in production and programme exchange. That is the kind of reference point that helps when your pipeline debates drift into vibes.

Practical take for production people

Treat the release like a compact pipeline exam. Download the encodes and frames, throw them at your review stack, test your HDR monitoring chain, and see what breaks first. If you plan to reuse any assets, read the license terms carefully, because attribution requirements can collide with real-world deliverable constraints.

https://studio.blender.org/projects/singularity/

The post Blender Singularity lands in 4K HDR 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.

For those who don’t know the tool: Blender is the free all in one DCC for modeling, animation, rendering, and export tasks like USD, with Eevee for realtime previews, Cycles for finals, and a Compositor that keeps quietly expanding its job description.

The release vibe: refine, then refine again

Blender 5.1 arrives with a clear theme: make everyday work feel lighter. The focus sits on quality of life improvements, stability, and polish, following a “Winter of Quality” push that solved 350 important issues and also cleaned up code to make future improvements easier.

That mindset shows up everywhere. Some changes are the sort you notice instantly. Others only reveal themselves after a week, when you realize you have not sworn at a dialog box even once. Progress comes in many forms. It is still the same familiar toolset. The difference is how often it gets out of your way.

Raycast: a shader node that likes to ask questions

A new Raycast shader node lands in the material system, built around a simple idea: shoot a ray, get useful surface information back, and use it to drive looks. That unlocks effects that rely on the closest point on a surface from the ray source, or the distance to it. There are demo files showing setups like toon shading and an X ray render effect.

There is also a practical warning: Raycast can be computationally expensive, and baking its output is suggested as a way to improve render times when needed.

Rendering: faster compiles, leaner memory, quicker frames

On the realtime side, Eevee speeds up material compilation by pre processing shader sources. In the standard Barbershop text scene benchmark, GPU shaders compile 25 to 50 percent faster across operating systems. Memory also gets attention. Eevee reduces texture memory use via texture pooling, helping scenes fit into less VRAM.

Cycles picks up performance gains too. GPU rendering improves by about 5 to 10 percent for many scenes, and HIP RT ray tracing is enabled by default on AMD GPUs. If your day includes lots of lookdev iteration, the combined effect is straightforward: fewer pauses between decisions.

Animation and rigging: the biggest speed win in the room

If you care about playback, Blender 5.1 comes with a headline worthy improvement: actions and shape keys evaluate significantly faster, with reported gains ranging from 4 percent to 304 percent in frames per second depending on the file. For cleanup work, the Graph Editor adds a Gaussian smoothing modifier that smooths curves non destructively. It is also explicitly described as resource heavy, with guidance not to use it on too many curves at once.

There are also small but practical timeline and editor touches that help animation feel less fiddly, like interpolation line colors indicating interpolation type in the Dope Sheet and menus.

Compositing and editorial: nodes that earn their keep

The built in Compositor adds a Mask to SDF node. It converts a mask into a Signed Distance Field by computing the distance of each pixel from the mask edges. That supports effects like edge glows, eroding or dilating mask edges, and distance based effects like procedural blurs.

The compositor also gains utility nodes including Boolean, Integer, Vector, and Index Switch, plus support for the existing Radial Tiling node. Speed matters here too. Several key nodes are faster, including Blur, Directional Blur, Vector Blur, Glare, Lens Distortion, and Anti Aliasing, described as 1.2x to 2x faster.

In the Sequencer, the Blade tool adds a box gesture that supports ripple editing, aimed at quicker cutting. Taken together, the message is clear: the VFX and video toolsets are being treated like first class citizens, not the side quest you only visit when your shot count gets scary.

Modeling and sculpt: a pile of small wins

Modeling sees a mix of performance and wrokflow tweaks. Filling for text objects improves, expanding the types of fonts that behave well as 3D text. Filling in general is up to five times faster, especially for n gons with many sides. Snapping adds an option to snap to the center of faces. In sculpt and paint, one visible addition is a Blur brush for blurring surface colors in Sculpt mode.

Grease Pencil: holes, at last

Grease Pencil gets notable workflow improvements, including better handling of strokes and fills and new ways to cut holes in shapes. Holes in fills can be created either via new operators that perform Boolean style operations or via the SVG importer. The draw here is practical: importing SVG and PDF content becomes easier to integrate without the same fill weirdness described in the feature overview. If you have ever built a workaround stack just to preserve negative space, this one lands with a satisfying thud.

Geometry Nodes: more rig friendly, more volume friendly

Geometry Nodes adds a Bone Info node that makes it possible to access bone position data. There are also new nodes for working with volume grids, including nodes for dilating, eroding, and clipping volume grids.

UI, file I O, and pipeline glue

The UI picks up just under 100 fixes and feature improvements, including the ability to search for controls by name in Preferences. Other practical UI touches include resizing quad views interactively by dragging the center point, and copying and pasting nodes between separate instances. On file formats, new options include AVIF export. Updates also land for USD, glTF, and FBX, with FBX files now including Shape Key normals for better compatibility with game engines like Unity.

For pipeline integration, support includes Python 3.13 and OpenColorIO 2.5, matching the CY2026 spec for the VFX Reference Platform. For virtual reality projects, the arc teleportation system is described as completely rewritten, and OpenXR is supported on macOS.

Availability and licensing

Blender 5.1 is a free download. The source code is available under the GPLv3 license. That free and open model is not new, but it still matters. It shapes how fast features get tested in the wild, how quickly workflows spread through studios, and how often a random late night fix becomes a shared win by morning.

The only remaining job is the boring one: install, test, validate, and only then roll it into serious work. Even a tool with a good mood still deserves a proper pipeline check. And yes, the Blender Foundation clearly wants this release to feel like a calm upgrade, not a reinvention.

https://www.blender.org/press/blender-5-1-release/

The post Blender 5.1 is here first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

iCrowds Generator now ships as version iCrowds 2.0.0 and adds a new Ragdoll system. The update targets physics-driven crowd motion and lets characters switch from regular animations like walking or running into ragdoll motion after collisions or falls. The toolset gives artists control over when and where ragdoll behavior kicks in.

Less wrestling, more falling down

iCrowds aims to deliver fast, believable results directly inside Blender without forcing a complex physics setup or manual constraints. The add-on supports the included iCrowds characters and also supports custom models. The same update pitch calls out VFX work, action scenes, cinematics, and big environment population like stadiums and city crowds as typical uses.

Ragdolls can turn clean crowd motion into readable chaos, and this update focuses on that moment where an agent stops acting and starts obeying simulation. When you control exactly where ragdolls appear, you can keep background motion consistent until the precise beat where someone gets clipped, trips, or hits the ground, then let the sim take over. That shift matters most in action shots, where timing and silhouette carry the beat. It also matters in evacuation style setups, where the Fluid system lets you steer large-scale flow while you still demand local reaction.

The crowd brain, the crowd river, and the crowd herd

iCrowds includes a City system that drives needs-based behaviour. Characters react to hunger, sleep, fun, and more, acting on those needs autonomously. iCrowds also includes a Fluid system that hands you full artistic control over crowd movement. The same feature set is useful for emergency evacuation visualisation, where you guide characters toward locations or repeaters and set up avoidance zones. Because when there is an emergency, someone is going to Ragdoll! The Walkers System focuses on pedestrian traffic, and the Stadium system targets populated venues with flexible distribution methods. The Scatter toolset rounds out the package with additional flexibility.

Pipeline reality check, with Parametra in the room

iCrowds positions itself as an integrated crowd simulation system for Blender with distribution and simulation features like Orientation, the Walkers System, a Vertex System for mesh-vertex placement, and a Ground System for terrain scattering with density control and masking.

The product page also claims hybrid control. It suggests you can use distribution systems for precise placement, then switch to a Fluid Engine for physics-driven movement and avoidance. The same page says it optimizes cinematic rendering for Eevee and Cycles.

Treat those claims like you treat any fresh sim feature: you trust it after it survives your shots, your cache budget, and your inevitable layout tweak at the worst possible time.

Pricing, compatibility, and the boring bits that matter

The Superhive listing shows iCrowds 2.0.0 at 19 US dollars, compatible with Blender version 4.5, render engines Cycles and Eevee, and the license as GPL.

The post iCrowds 2.0.0: Ragdolls arrive, dignity leaves first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Fantasy Hut Generator is a procedural fantasy hut generator made with Geometry Nodes in Blender. The intent is simple: lots of available parameters to customize the hut and create very different variations, without leaving your node based comfort zone or manually rebuilding the same shapes over and over.

Not every control is expected to be self explanatory. Some parameters ship with descriptions, so hovering the UI can tell you what a setting does. It is like having a tiny tooltip translator for your future self, right when geometyr starts getting bold.

I've made a procedural Fantasy Hut Generator with Geometry Nodes and made it available for free :D
byu/ianfontova inblender

Getting it into a scene without summoning chaos

The setup is meant to be brought into projects as a blend file. One workflow is appending the hut blend file into your scene. Another workflow is treating it like an asset: store it in a folder you choose, then add that path in Blender Preferences under File Paths and Asset Libraries.

There is also mention of alternative files that include different hut ideas, presented as extra downloads. The exact contents of those ideas are not described here. Not independently verified at press time.

Resolution knobs that act like LOD, politely

The generator includes resolution controls for various hut elements, positioned as a way to optimize for your project. The idea is to push high resolution for close up shots, then drop resolution for far away shots when the hut is just doing background work and trying not to become the reason your scene file needs its own project manager. This resolution framing is about tuning the output, not swapping to a different model. You stay inside Geometry Nodes and steer the detail where it matters.

Cycles foliage tip, because alpha always finds a way

If you plan to use the hut foliage such as vines or grass in Cycles, there is a specific render recommendation: set Transparent Max Bounces in Render Properties to 24 to 32. That is presented as a practical setting tip, not a magic bullet. It is still worth testing in your own shot context, because alpha-heavy foliage loves to behave differently the moment deadlines appear.

Animations, Scene Time, and the fps cliff

Animations for the vines, the grass, and the smoke rely on the Scene Time node. There is a performance caveat: Scene Time can have a brutal impact on fps. The described behaviour is that using this node forces the whole node tree to recalculate on each frame, even if it is used at the very end of the tree, or even if it is totally disconnected.

If you are not going to use animations, or you want to disable them temporarily before a final render, there is a suggested workaround: mute the Scene Time node to get rid of the low fps. The guidance is very specific. Look for an orange frame in the Geometry Nodes editor, select the Scene Time node, and press M.

There is also an extra gotcha. The low fps issue might still trigger even if the Scene Time node is muted when you animate the hut, such as animating the overall object position. So, there is an alternative solution designed to sidestep the problem: an option to Bake the hut.

Bake it and move on with your life

The bake option is living inside a green frame in the Geometry Nodes editor. Click Bake, then choose Still if you do not need animations, or Animation otherwise. The goal is to get a stable result without dragging the viewport through frame by frame recalculation.

This is also the moment to do your usual pipeline hygiene. Test new tools and innovations before using them in production, confirm the output survives your render path, and make sure resolution settings do not silently change the look between shots.

Compatibility and pricing

Compatibility is listed for Blender 5.0 and 5.1. Pricing is listed as 0 dollars and up, effectively free. But, you can pay for it and be a good person if it helps you!

https://ianfontova.gumroad.com/l/FantasyHutGenerator

The post Let’s Build a Blender Hut This Weekend! first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

3D artist and motion designer Jörg Grubmüller has released LimbKit, a procedural tool for generating 3D hands and feet in Blender. It is described as Geometry Nodes-based and intended to help artists block out hands and feet quickly, including paw-like variants for creatures, with an emphasis on stylised work.

The core idea is simple: instead of sculpting extremities from scratch, the workflow centres on placing readymade fingers and toes onto a palm or base mesh, then generating a merged result that can be adjusted via controls for finger length, spacing, orientation, and overall shape. The promise is not “perfect hands”, but “hands that exist”, which is often the bigger scheduling problem. LimbKit includes realistically proportioned base models for hands and feet that can be refined manually, even if the tool’s stated sweet spot is stylised characters for illustration or animation.

What it does, and what it does not claim

LimbKit’s stated function is procedural generation and adjustment of hands and feet inside Blneder using Geometry Nodes, with the output merged into a single mesh that you can further tweak via parameters. That positions it as a fast starting point for modelling and lookdev, particularly when you need to iterate on silhouette and proportions without burning hours on knuckles.

There are no stated guarantees in the provided sources about rigging readiness, deformation behaviour, UV layout, subdivision performance, or downstream interchange. If you need clean edge loops that match a house rig, consistent joint placement, or predictable deformation under extreme poses, you still have to test the generated meshes and decide whether LimbKit is a blocker, a base, or a throwaway placeholder.

Grubmüller’s background is leaning towards cartoon-style character work, including prior work as a Senior 3D Character Modeler at animation and VFX studio arx anima. That does not limit what the tool can be used for, but it does explain why the initial framing is stylisation-first: it is aimed at readable shapes and fast iteration, not forensic anatomy.

Download and library workflow

LimbKit is a free download hosted on Gumroad and is stated to be compatible with Blender 4.5+. The available walkthrough information describes a “pay what you want” style flow where entering a zero value enables a free download, followed by an email-based download step.

Setting it up as an asset library is done by pointing Blender’s Preferences File Paths to a folder containing LimbKit assets, switching an import method setting from “pack” to “appended”, then accessing the assets from the Asset Browser drop-down. From there, the described interaction is drag-and-drop: pull hand and foot assets into the scene and start adjusting parameters.

Controls, gizmos, and the “procedural bits”

The supplied walkthrough description goes further into how LimbKit presents itself once assets are in the scene. It describes procedural controls in the modifier stack, including a primary control labelled “Digim Master” and scaling tools for global and per-finger adjustment. It also describes an optional gizmo-based control mode that allows moving individual finger elements forward or backwards.

Additional controls include adjustable bending styles and colour parameters that apply across the assets, including separate options for stylised variants that can alter finger length and pointiness. The walkthrough also mentions parameters described as controlling the bend tip and the bend centre.

Practical pipeline fit

LimbKit sits comfortably in the rough modelling stage when the goal is speed and iteration: building a hand silhouette that reads, matching proportions across a character set, or getting something into layout, previs, or a stylised render without dedicating half a day to digits. The workflow can be useful for motion designers and generalists who are allergic to sculpting but still need convincing extremities on screen.

What it should not be assumed to replace is the careful part: production topology, deformation testing, UV standards, and the inevitable “why does the thumb do that” notes once animation starts. LimbKit looks like a practical way to get to a first pass quickly. Whether it becomes your base mesh generator or your temporary placeholder depends entirely on your worlflow and your tolerance for procedural geometry in hero assets.

Fact check reminder: New tools and innovations should be tested before use in production.

https://joergsla.gumroad.com/l/limbkit

The post Neat LimbKit gives Blender a hand, literally first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Three first-semester students, one task to develop an animated short film and immense ambition – that’s where the first steps of “No One’s Light” headed off from in autumn 2024. Over the next 12 months, another animated first-year film at HFF München came to life, helping us VFX students develop filmmaking skills hands-on.

by Michael Powers, Christoph Schmidt, Julia Zenk

Finding an idea

The first step in creating our animated movie was to develop a story and concepts. The freedom to create a fully animated short film opened up limitless possibilities in the visuals, so we already knew we wanted to stick with genres that take advantage of this: fantasy and science fiction. Together, we gathered about 50 possible ideas, ranging from time travel to epic worlds of dragons and aliens. But amongst those, one story particularly stood out above the rest for us: an interstellar worker exploring a planet that comes to life at night.

We started this project with an ambitious approach. Ideas ranged from the main character initially encountering numerous alien offspring and their mother, to setting up a giant main base for the corporation our main character is working for. Lots and lots of characters, assets and settings. We began asking ourselves whether all these elements were necessary for our plot and whether we could find a more efficient way to tell a story.

With the help of our lecturers, Prof. Jürgen Schopper, Dr Rodolfo Anes Silveira, and Berter Orpak, we worked to reduce the number of characters and places while keeping the most important plot elements for a concise story. This helped us to focus on learning new skills within an efficient framework. Especially because it needed to be simple and easy to understand within 5 minutes. Eventually, we figured out the only three components we needed for the story to work: an astronaut on a mission, an alien baby creature, and intergalactic planet landscapes. That way, we had more time to focus on the next steps while still following a solid story flow. During this stage, our producer Leonhard Schmid, who is currently studying production at HFF München, hopped on board to support us with administrative tasks.

A world, far, far away

Creating a fantastic world with original characters, while all fitting together in one look was a major task we were facing. First up, the planet – the environment our whole story is set in. How could we create otherworldly landscapes that are distinct from a familiar earthly look? Our main inspiration was underwater landscapes, such as coral reefs and deep-sea creatures, environments that fit well with science fiction designs.

This way, we could give our planet a distinctly otherworldly appearance, centred around bioluminescence as the core aesthetic. Flowers and creatures glow in the dark, bringing the planet to life at night and reinforcing its alien nature.

The main plant that incubates the alien eggs was particularly difficult to find. It needed to read clearly as a plant while avoiding any direct resemblance to recognisable Earth species. At the same time, we wanted to prevent the design from immediately revealing that the “fruit” inside it was actually a living creature. The smaller plants that grow from falling seeds were not modelled; instead, they were created in Blender’s geo nodes, allowing us to easily fill the landscape with them.

The geo nodes system for the plants consists of multiple stages. These are the spores, seeds, which are not seen, and the plants themselves. For organisational purposes, each stage is a separate object containing the node tree. Control groups were used to make, for example, the planet’s surface easily available across multiple node trees and smoothly exchange data between stages.

The spores are emitted in a spherical volume around the creature and are simulated with a simple constant downward velocity and some noise. Once the distance between a particle and the ground gets sufficiently small, it stops moving and stores the elapsed time in frames since it hit the ground.

In the next stage, points are distributed across the ground. Through proximity to certain control meshes, the density is art-directable. As a next step, all spores that hit the ground are brought in. Then invisible growing spheres are instanced and realised on those points, with their size corresponding to the elapsed time since the particle hit the ground. In a simulation zone, the seed points are set to “activate growth” (growthTrue) if they are in a certain range of the expanding spheres. If a seed’s growth has been activated, the growth factor will begin to accumulate.

In the last stage, curves with random length are instanced on the seed points. They are displaced such that the curve tangent points in the normal direction of the planet’s surface near the root and points straight up near the tip. After that animated noise is applied, and the curves are trimmed based on the growth factor. Finally, data such as the spline factor and a random float for each plant are stored for use in the Material.

Although variation in length and thickness is evident in the plants, they do look quite similar. So to avoid the image feeling cluttered and noisy, especially in the wide landscape shot, we made use of a shallow depth of field, rendered in engine, as well as shifting the hue and brightness of further away plants slightly. This way, the overgrown bioluminescent aesthetic was maintained while keeping the image readable.

Another challenge was designing the main character, Aamu. Here, we were faced with some unexpectedly tricky questions: What kind of helmet should she wear? Should she wear one at all? Should she be able to take it off? Will the environment reflect in her visor?

Each of these decisions influenced not only her final appearance, but also the types of scenes we could realistically include in the film. We put a lot of emphasis on Aamu’s design, as she appears in the majority of shots and thus carries a lot of visual weight in the film. Regarding the latter of the questions above, in the end, we even made use of the reflective visor as an active element of our storytelling (see image)

Tied closely to the astronaut’s role in the story was the canister she used to collect the eggs. Early designs featured a large spike that would impale the targets. Given that it is later revealed that these eggs contain living animals, we deemed this approach a little too violent and opted for a grabber-style design instead. To further emphasise the corporate nature of the energy-collecting company behind the mission, we deliberately branded both the canister and the astronaut’s suit with the company’s logo.

The alien creature’s design was closely tied to the plant it originated from. We wanted this relationship to be immediately understandable to the audience, which led to the idea of having the creature carry its own egg as part of its body. In keeping with our underwater concept, the main inspirations here were crabs, moths, and other insects.

Kicking off the plot

Before we began actively working on our film, we did not forget an important foundation for the project: organising all the shots and assets to ensure an overview of every task at all times. Our VFX production professor, Sinje Gebauer, shared valuable insights from the VFX industry and tips on structuring the project in the pipeline database, Flow. This helped us immensely in keeping track of all the versions and noting down feedback.

In conjunction with Flow, we used Prism as our main pipeline tool for folder organisation and file versioning. The default file structure, previously set up by our Pipeline TDs Jonas Kluger and Wilfried Pollan, met our file management needs. Closer towards the end of the project, we manually added folders for handovers to sound, grading and mastering.

Throughout the visualisation of the story, we worked closely with our lecturers and test audiences to make iterations. We wanted to leave the story’s ending a little open, letting the audience interpret what might happen to the astronaut after her decision to delete the planet from the database.

Before we could begin animating the astronaut and the alien, we first had to create a rig – a skeleton underneath the model that allows us to move the character. For all our character rigs, we used the Blender Tool CloudRig, which was developed by Demeter Dzadik and introduced to us by him. The surfaces were painted using Substance Painter.

For the astronaut main character, it was important to have a smooth IK/FK switch given her frequent interactions with her container-harvesting tool. This was most important when she inserts it into the storage space. CloudRig helped a lot, as it comes with a very reliable, user-friendly system for IK/FK switching.

When it comes to our alien creature, it is mostly moving around by flying. For the flapping of the wings we used the sine wave generator in the f-curve modifiers in Blender.

Since we had the constraint of a 12-month student production, we could not spend ages refining the animation, which is why, on some shots, we skipped blockout with constant interpolation and jumped straight into splining.

As our team consists of passionate animators, we decided to animate every character manually with keyframes. Nevertheless, credible movements were highly important to us, so we hired professional actress Franzi Frey to reenact all stages of our main character’s journey for animation references. With the help of our lecturer David Emmenlauer, we also ventured in motion capture technology by XSense and recording movements, in case of needing to rely on those as a fall-back option.

Additional sessions with our animation lecturer, Prof. Melanie Beisswenger, improved our shots immensely with valuable feedback on what our characters are moved by, how they would express their emotions, and what credible movements are in each situation. All these steps helped us learn to apply the principles of animation in 3D software.

Compositing & Finishing

While most of our 3D work up until this point was done in Blender, one of the last steps in our pipeline – compositing – was happening in Nuke. Martin Tallosy introduced us to the program with industry expertise. In the compositing stage, we adapted all scenes to match a consistent appearance and added final touches for a cinematic look. The in-house grading in HFF München polished the final look of our film, thanks to Claudia Fuchs.

We rendered several passes out of Blender for use in Nuke. In addition to the ZDepth, position, diffuse and glossy light and colour, emission, environment, and ambient occlusion were included in the .exr sequences. This made the image sequences’ file size quite large, but allowed us a lot of control in compositing. Especially, the ZDepth was used on multiple occasions for depth of field. Furthermore, a combination of ZDepth and the Z component of the position gave a very nice, convincing impression of lingering mist.

We used ACES for rendering and compositing to ensure consistency across the final stages. In compositing, we always rendered mattes for the character and creature. Almost no colour correction was done in comp.

Issues in grading mainly stemmed from us discovering technical issues with the render. While working on the film in a fully lit room, we spotted a couple of errors (such as flickering or corrupted geometry), as soon as we saw it on a big cinema screen in the dark in-house grading room for the first time. This resulted in a couple of iteration loops until we could use the final renders for grading.

During the final grading sessions, Claudia contributed significantly to the film’s visual success. She showed us how the story could be emphasised greatly with colour, emphasising stark reds and oranges associated with the corporation and contrasting them with the cool teals and blues of the planet. Furthermore, she ensured those colour statements were consistent across all the shots.

While movies contain a lot of work for the final images, we also need to mention our supporting team, which contributed to the audio and thus, brought a final touch to make our story come alive.

Our music was written by composer Fabiola Wörter, a recent graduate of the University of Music and Theatre, who added to the otherworldly feeling with a captivating soundtrack. The whole score carries the story and pushes the audience even deeper into an otherworldly adventure. Our sound design was created by Stefan Möhl of HFF München, who helped us find the right sounds for an alien planet. Who would have guessed that small aliens sound exactly like capuchin monkeys?

Final Thoughts

All in all, we are very happy with our journey that created “No One’s Light” – we learned to work efficiently within a team structure, acquired a new skill set at each stage, and now have a short film to show for it. As our main character Aamu finds out the strength of personal choice and the beauty within the unknown, we hope to inspire many viewers of our film!

The film is now in submission for several festivals and events, with pending responses. Once there is an update, we are happy to share upcoming screening dates on our film’s Instagram account.

The full Team of “No Ones Light”

Script · Concept Art · Modelling   Texturing ·  Rigging ·  Animation · Compositing	Michael Powers Christoph Schmidt   Julia Zenk
Producer	Leonhard Schmid
Music	Fabiola Wörter
Voice & Reference Acting Aamu	Franzi Frey
Project Supervision	Prof. Jürgen Schopper
Project Consultant	Dr. Rodolfo Anes Silveira
VFX Producing Supervisor	Prof. Sinje Gebauer
Visual Effects Pipeline TD	Jonas Kluger   Wilfried Pollan
Mentor 3D Animation	Berter Orpak
Mentor Compositing	Martin Tallosy
Line Producer	Ina Mikkat
Team Assistant to Line Producer	Ron Sikkes
Team Assistant	Petra Hereth
Editing Consultant	Prof. Beatrice Babin  Prof. Michael Palm  Yuval Tzafrir
Color Grading	Claudia Fuchs
Rerecording Mixer & Sound Designer	Stefan Möhl
Postproduction Supervisor	Christoffer Kempel
Scheduling	Beate Bialas  Sabina Kannewischer
Editing Support	Christine Schorr  Yuval Tzafrir
Technical Support	Benedikt Geß  Florian Schneeweiß
Rental HFF Munich	Rainer Christoph  Boris Levine
Studio Management	Peter Gottschall  Andreas Beckert
Conforming	Aaron Kuder
Tutors	Prof. Melanie Beisswenger, Prof. Michael Coldewey, Demeter Dzadik, David Emmenlauer, Kathrin Hawelka, Benc Orpak, Dr. Walter Stehling

The post On a Mission: Creating “NO ONE’S LIGHT” first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

KIRI Engine has released Scatter, a free object scattering add on for Blender. The plugin provides three placement modes that cover manual layout, procedural distribution using Geometry Nodes, and physics based scattering driven by Blender’s rigid body system. The developer positions the release as a response to the cost barrier of existing advanced scattering tools. According to KIRI Engine, many established add ons come with significant price tags, so for Blender artists who either lack budget for commercial plugins or are early in their learning curve.

Three modes, three workflows

Scatter provides three distinct placement modes. Each addresses a specific production scenario rather than attempting to unify all behaviours into a single opaque system.

The Click mode is described as a point and shoot workflow. It enables manual placement of individual assets directly in the viewport. This mode targets hero assets and composition critical elements where precise positioning, orientation and visual balance matter more than procedural coverage. For layout artists and lookdev teams, this is effectively a structured alternative to duplicating and transforming objects by hand.

Simple Scatter applies a non destructive Geometry Nodes modifier to a target mesh or curve. The distribution is procedural and remains editable. This is intended for large scale coverage tasks such as scattering vegetation across terrain, debris across floors, or objects along splines. Because it relies on Geometry Nodes, the behaviour integrates with Blender’s native node based instancing system. Geometry Nodes in Blender provide procedural control over point distribution, instancing and attribute driven variation. Scatter builds on that system rather than replacing it.

Physics Scatter uses Blender’s Rigid Body physics engine to drop objects into a scene and allow gravity and collision to determine their resting state. This mode is aimed at natural stacking scenarios such as rock piles, filled containers, cluttered surfaces or loosely arranged props. Instead of manually tuning offsets and rotations, users simulate gravity driven interaction.

Interactive physics control

Within Physics Scatter, an Interactive Mode enables real time direction of falling objects during playback. Users can activate Wind and Vortex force fields and toggle gravity while the simulation runs.

In Blender, force fields such as Wind and Vortex influence rigid body objects during simulation. Wind applies directional force. Vortex applies rotational force around an axis. Gravity toggles affect global downward acceleration. Scatter exposes these controls to allow artists to shape the outcome of object drops during simulation rather than relying solely on preconfigured settings. This provides a degree of art direction over what would otherwise be purely physics driven motion. It remains dependent on Blender’s rigid body solver and its constraints.

Non destructive procedural coverage

The Simple Scatter mode applies a Geometry Nodes modifier to the target object. Geometry Nodes in Blender are non-destructive by design, meaning that the underlying mesh remains unchanged and the node tree can be edited at any time. Scatter leverages this behaviour for environmental coverage. Because the modifier is attached to meshes or curves, distribution can follow surfaces or paths. Typical use cases include grass over terrain, debris on architectural floors or repeated assets along splines.

Manual placement without friction

The Click mode targets precision tasks. It is intended for placing hero assets with full compositional control. This mode likely reduces repetitive transform operations by integrating placement into a structured toolset.

Asset ecosystem integration

At launch, KIRI Engine provides one free KIRI Asset Pack alongside the add on. Additional packs may be developed if there is sufficient user interest. Scatter includes a preview gallery and loader for KIRI Asset Packs. The add on is designed not only as a placement tool but also as an entry point into KIRI’s asset ecosystem. The company frames this as a way to manage asset packs more easily.

Free, but not feature vague

Scatter is explicitly described as free. There is no mention of subscription requirements, feature gating or trial limitations in the provided documentation. The stated motivation for releasing a free tool is to give Blender users access to scattering functionality without additional cost. This is presented as a response to the price of advanced third party tools.

Positioning against native tools

Blender already includes native instancing via Geometry Nodes and particle systems, as well as rigid body physics for dynamic interactions. Scatter does not replace these systems. Instead, it packages them into a dedicated add on with predefined workflows for common scattering tasks.

As always, new tools and innovations should be tested before use in production. At present, the facts are straightforward. Scatter is free. It relies on Blender’s Geometry Nodes and rigid body physics. It includes integration with a KIRI Asset Pack gallery. That clarity is refreshing. Teh rest is up to production testing.

// https://www.kiriengine.app/blender-addon/scatter-by-kiri-engine

The post KIRI Engine releases free Scatter for Blender first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

3D artist Alex Martinelli has released a Geometry Nodes setup for Blender that converts any mesh into a sponge-like structure using volumetric processing. The tool converts the input mesh into a volume grid and performs subtraction operations in volume space to create a porous internal structure. The resulting object can remain a volume or be converted back into a polygonal mesh inside Blender.

Procedural Sponge Modifier in Blender Geometry-Nodes.
Get it for FREE on Gumroad: https://t.co/6fGqdIBo7j#b3d #geometrynodes pic.twitter.com/rN5SVrGQkT

— Alex Martinelli (@5agado) January 15, 2026

The modifier is entirely procedural and non-destructive. Artists can adjust parameters controlling the density and scale of the pores, allowing for anything from mildly absorbent props to geometry that looks as if it should be left to dry near an open window. The approach avoids manual modelling and relies on Blender’s volume and Geometry Nodes systems rather than sculpting or texture-based tricks.

Volumes, bubbles, and bathroom acoustics

According to the creator, the tool requires Blender 5.0 or newer. Rendering guidance recommends using Cycles for volume output, as It handles volumetric rendering more reliably than Eevee in this context. This is not presented as a performance claim, merely practical advice from the creator. No benchmarks or render time comparisons are provided. The setup does not include presets for specific real-world materials. Any resemblance to kitchen sponges, bath sponges, or that one sponge that should really have been thrown away last year is purely the responsibility of the user.

Distribution and pricing

The Procedural Sponge Modifier is available via Gumroad with a base price of zero euros. Users can download the file for free or pay an optional fee. No additional licence terms or usage restrictions are specified beyond Gumroad’s standard terms. At press time, no formal documentation beyond the node graph itself is provided.

Production reality check

As with any Geometry Nodes asset that relies on volumetric processing, results will depend heavily on mesh scale, resolution, and scene settings. Artists planning to use the generated geometry in downstream pipelines such as export to other DCCs or engines should test conversions carefully. Dense sponge meshes can become very heavy very quickly, much like a real sponge that has absorbed far too much water and regret. New tools and procedural assets should always be tested in actual production environments before being adopted into established workflows, preferably before the sponge starts dripping.

https://sagado.gumroad.com/l/ucjwm

The post Blender turns meshes into sponges. Rubber duck not included first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

A new procedural sky and cloud system called Sky is now available for Blender via Superhive Market. The tool is built entirely using Blender’s Geometry Nodes and procedural shaders, allowing artists to generate and animate volumetric clouds and a full atmospheric sky directly inside Blender without relying on HDRIs or pre-rendered sky textures.

Sky is designed for use with Blender 5.0 and the Cycles render engine and focuses on physically based volumetric rendering. Both the clouds and the atmosphere are constructed at real-world scale, aiming for physically plausible light scattering and cloud behaviour rather than stylised shortcuts.

Included cloud types and artistic control

The asset includes four common cloud formations: cumulus, cumulonimbus, cirrus, and altocumulus. These cloud types can be combined and layered to build more complex sky setups and different lighting conditions, including daytime and sunset scenarios.

Because the system is procedural, users can adjust cloud size, coverage, and overall appearance, and animate these parameters over time. This makes the tool suitable for both still imagery and animated shots where cloud movement and atmospheric changes are required.

Physically based shading and volumetric rendering

According to the developer, the shaders used in Sky are based on research into air and water particle behaviour. The goal is to approximate realistic light interaction inside volumetric clouds rather than relying on simplified noise-only approaches. This makes the system computationally demanding, as expected from true volumetric rendering inside Cycles.

The product page notes that volumetric rendering performance depends heavily on hardware. A system with at least 16 GB of memory is recommended. As a reference example, a 720p render at 128 samples using an Nvidia RTX 4090 with Optix acceleration takes roughly six minutes.

Availability and pricing

Sky is available via Superhive Market and is sold under a royalty-free licence. At the time of writing, the tool is priced at 25 US dollars and is positioned as a ready-to-use Geometry Nodes setup for artists who want procedural skies and volumetric clouds without building their own node systems from scratch.

https://superhivemarket.com/products/sky

The post Sky: Geometry Nodes-Based Volumetric Cloud and Atmosphere System for Blender first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t now the tool: Dynamic Flow is a Geometry Nodes based water add-on for Blender by Blender Procedural, aimed at fast environment lookdev rather than fluid accuracy. Rivers first, splashes later.

Water without waiting

Dynamic Flow is a real time water simulation add-on for Blender developed by Blender Procedural and distributed via the Superhive marketplace. The tool is designed as a lightweight alternative to traditional fluid simulation workflows, focusing on interactive feedback rather than physically accurate behaviour.

The add-on generates flowing water surfaces that respond to terrain in real time. It does not use Blender’s Mantaflow solver or particle based simulation. Instead, it relies on Geometry Nodes to drive surface motion procedurally, allowing timelines to be scrubbed and parameters adjusted without baking caches.

The stated goal is rapid iteration for environment scenes such as rivers, coastlines, lakes, and islands, where visual plausibility is sufficient and turnaround speed matters.

Geometry Nodes, not physics

Dynamic Flow is built entirely on Blender’s Geometry Nodes system. Flow direction and velocity are derived from the underlying terrain geometry, with the water surface adapting to slopes, banks, and obstacles.

Because the system is procedural, changes to terrain or scene layout update immediately. There is no simulation cache to manage and no rebaking when assets move. This makes the add-on suitable for look development, layout, and concept work where scene elements are still in flux. The developer states that a lightweight grid is used internally to evaluate surface flow.

Foam, collisions, and interaction

Dynamic Flow includes automatic shoreline foam generation driven by proximity to terrain and scene objects. Foam behaviour is controlled through exposed parameters inside the Geometry Nodes setup, allowing adjustments to width, intensity, and motion. The add-on supports collision with objects and collections. Objects intersecting the water surface can influence flow patterns and create visible disturbances. The precision of these interactions is not described in detail, and there is no indication that secondary effects such as splashes, spray, or droplets are simulated. The system is limited to surface motion and does not model volumetric water behaviour.

Rendering and compatibility

Dynamic Flow works with both Eevee and Cycles. The water surface is standard Blender geometry with animated attributes and uses regular materials and shaders. No custom rendering features are required. The add-on requires Blender 5.0 or later and installs as a standard Blender add-on through the Preferences panel.

Positioning and limitations

Dynamic Flow is not intended to replace full fluid simulation tools. It does not simulate turbulence, buoyancy, pressure driven motion, or complex fluid interactions. It is positioned as an artist controlled, predictable system for surface water movement.

Pricing and availability

Dynamic Flow is available via the Superhive marketplace for 6 Dollars. No subscription is required. As with any new production tool, artists should test Dynamic Flow carefully before deploying it in active pipelines or client projects, particularly where determinism and render consistency are required. This remains advisable even if early results appear stable and behave exaclty as expected.

The post Dynamic Flow makes water move without waiting first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: Simply Cloth Studio is a Blender add-on for creating realistic digital clothing through real-time cloth simulation. It sits between modelling and simulation, offering a fast prototyping environment for artists who prefer geometry nodes over complex cloth setups.

Simply Cloth Studio 2.0 arrives as a complete rebuild for Blender 5.0, replacing every button, menu, and modifier with a cleaner, faster foundation. The developer, ViaceslavT, promises smoother simulations, a modernised interface, and far less guesswork when setting up garments.

The new window management system keeps the workspace tidy, while adaptive structures automatically handle subdivision and collision. Documentation is available in English and Japanese and can be downloaded from the user account page.

Wrinkles that know what they’re doing

Version 2.0’s adaptive wrinkle system analyses mesh angles and curvature to generate weight-based wrinkle maps on the fly. Artists can control wrinkle intensity, direction, and detail level using Blender’s geometry nodes, with optional adaptive subdivision when extra precision is needed. A built-in “Merge Distance” setting helps fix shading artefacts when the model scale differs from defaults, a small but practical improvement.

Cleaner sewing, sharper tearing

The interface now separates the workflow into Start, Design, and Finish stages. Each stage exposes only the relevant controls, collision setup, pattern cutting, or final baking. A new sewing logic improves edge matching and reduces mesh collapse during gap closure. Simply Cloth Studio also integrates a static tearing tool, based on Simply Tear Lite. A Pro version exists separately for dynamic, collision-based tearing, but the included Lite tool is enough for most cloth breakup needs.

Paint your clothes directly

Paint Cloth, the add-on’s sculpt-based garment extractor, lets artists paint clothing directly onto a model and simulate it as a new object. The system includes sculpt brushes for bending, grabbing, inflating, and twisting cloth surfaces. UI bugs in these brushes have been fixed, along with caching and keyframe baking.

Versions, pricing, and upgrades

Simply Cloth Studio 2.0 comes in three paid editions:

• Studio 2.0 – Full Functionality: USD 36.
  All core simulation tools, cloth presets, sewing, and pin systems.
• Studio 2.0 + Cut & Sew Asset Library: USD 66.
  Adds a library of 200+ editable garment patterns designed for live simulation.
• Full Commercial Licence: USD 170.
  Includes both add-on and asset library, licensed for up to three seats per industry sector.

Anyone who bought version 1.5 on or after 16 July 2025 can claim a free upgrade by contacting the developer directly.

Under the hood

The 2.0 update fixes multiple long-term bugs: Paint Cloth extraction errors, sculpt brush UI misalignment, shape key cache problems, and broken keyframe baking are all marked resolved. Geometry Nodes compatibility has also been tightened, ensuring stable performance across Blender 4.1 and later. The add-on now runs faster in viewport playback and includes the Optim Cloth mode for low-resolution previews. Users can bake simulations to cache or keyframes, and the new Shrink and Pin systems have better vertex-layer control.

The two cloth packs, explained

The Cut & Sew Asset Library (included in the USD 66 and USD 170 versions) offers flat, editable patterns for simulation inside Blender. The Simply Clothing Pack, sold separately, contains the same 200+ garments as pre-simulated meshes—ready to drop into scenes without running cloth physics. Same assets, different intent: one for artists who simulate, one for those who just need clothes. All documentation and FAQs are available online, with a Discord community and direct email support.

https://superhivemarket.com/products/simply-cloth/

The post Simply Cloth Studio 2.0 rebuilds cloth in Blender first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Independent Blender developer Eric Charles has released EC Wood Grain, a Geometry Nodes setup that procedurally generates volumetric wood patterns inside Blender. The system uses a single reusable node group that can be appended to any scene and applied as a modifier without manual node editing.

EC Wood Grain operates fully inside Blender’s Geometry Nodes system, creating volumetric detail rather than surface textures. This allows 3D artists to carve realistic rings, displacements, and orientation patterns directly into geometry, rather than relying on bump maps or shaders. The modifier exposes several parameters, including ring spacing, wobble, displacement depth, and mask controls. Orientation can be switched along the X, Y, Z axes or spherical coordinates, offering flexible control over directional wood grain. Masking options enable users to exclude flat bases or selectively apply grain patterns.

Once baked, the resulting mesh can be exported for rendering or physical output, including 3D printing. Because the grain exists as actual geometry, not shader detail, prints retain visible and tactile wood structures. Artists can even vary ring density or axis direction to simulate natural imperfections, producing a more organic surface in FDM or resin prints.

Non-destructive control, print-ready results

The node setup is entirely procedural and non-destructive until applied, allowing parameters to be fine-tuned in real time before committing the geometry. Once baked, the resulting mesh can be exported for rendering or physical output, including 3D printing. Charles notes that the tool has been tested in Blender 4.0 and newer, including versions 4.5.1 LTS and 5.0.1 at the time of publication. The file ships as a .blend scene containing the complete Geometry Nodes network, ready for direct use or appending into existing projects.

Pricing and availability

EC Wood Grain is distributed via Gumroad on a name-your-price model, with a minimum contribution of 3 Dollars. The package includes the .blend file and full node setup. No licensing restrictions or installation dependencies beyond standard Blender functionality are mentioned. As always, users are advised to test the tool in a controlled environment before deploying it in production pipelines.

The post Procedural sawdust: EC Wood Grain hits Blender first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Better Bend introduces a controllable way to bend geometry inside Blender 5.0 and later. Built entirely in Geometry Nodes, it avoids the instability and distortions common in the Simple Deform modifier. The node group provides clean bending that can be applied across multiple objects within procedural scenes.

The system includes viewport gizmos that allow artists to set bend start and end points, orientation, and direction directly in the scene. The control feels immediate and visual, without relying on empties or manual transforms.

Procedural, non-destructive, repeatable

Unlike traditional modifiers, Better Bend is fully non-destructive. Because it operates in the Geometry Nodes context, the same setup can be reused or driven by animation data. This makes it suitable for motion design, product visualisation, and any procedural modelling workflow requiring repeatable deformation.

Users can control the bending region, falloff, and strength, while maintaining mesh integrity. According to the author, the tool was built to produce consistent results across multiple objects, a weak point in Blender’s existing deformation stack.

Better Bend was created by Nate Jolly, a Miami-based 3D designer and physicist behind NZJ 3D. With a background in physics and astrophysics from Florida State University, he applies mathematical precision to motion graphics, procedural animation, and tool development for Blender artists.

Use

Installation is straightforward: download the .blend file from Gumroad, then open it in Blender 5.0 or later. The Better Bend node group can be appended into any project via Blender’s File > Append function, selecting the Node Group from the source file. Once imported, it appears in the Geometry Nodes editor under your node list. To use it, create a new Geometry Nodes modifier on your target mesh, add the Better Bend node group, and connect it between the input and output geometry sockets. Parameters for bend start, end, angle, and axis are exposed and adjustable in the modifier panel or via the on-screen gizmos in the 3D Viewport. The gizmos allow direct manipulation of bend direction and limits without relying on empties or manual transforms, making it suitable for fast, iterative deformation setups.

Availability and requirements

The download includes a .blend file with the node group and several example scenes. It requires Blender 5.0 or newer and a basic understanding of Geometry Nodes. The tool is priced at $12 or more, available through https://nzj.gumroad.com/l/xgpzcd.

As with all third-party tools, Digital Production recommends testing the node setup in a controlled environment before using it in production pipelines.

The post Better Bend: A Gentler Way to Deform in Blender first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Blender 5.0 has entered its release candidate stage, signalling that the open-source 3D suite is only days away from full release. The RC phase runs until 18 November 2025, after which the final build will be issued if no critical bugs emerge.

What’s coming?

Among the major changes are full integration of the ACES 1.3 and 2.0 colour management systems, giving artists more accurate tone-mapping and consistent colour handling across production pipelines. Cycles receives additional rendering refinements, improving sampling performance and light path accuracy. The Compositor gains expanded node functionality and faster feedback, while Geometry Nodes continue to grow with broader procedural modelling capabilities.

https://twitter.com/Blender/status/1988928919479705786

The user interface has also undergone refinement, targeting consistency across editors and providing clearer access to scene and node controls. Together, these updates aim to enhance usability and fidelity without altering Blender’s open, modular workflow philosophy.

The release candidate can be downloaded via Blender’s build portal, and users are invited to provide final testing feedback through the official Blender Survey 2025 before the version is locked for release. Blender 5.0’s final release is expected shortly after 18 November 2025.

The post Blender 5.0 hits release candidate! first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

With Roads, artist Marco Pavanello (publishing under Wolf on Superhive Market and on Gumroad) offers a deceptively simple Blender modifier setup for fast, procedural street generation. The tool lets users create complete, textured roads by extruding vertices from any mesh object.

Once a vertex is extruded, a full road mesh appears. Move the vertex, and the path curves dynamically—no additional modifiers or manual UV mapping needed. As the developer describes it: “Extrude a vertex and you’ll get a road, move it and you will create a curve, everything else is magic.” The implementation is built entirely on Blender’s native modifier stack and geometry nodes, meaning no compiled code or scripts are required.

Procedural by Design

Every aspect of the setup is procedural, from the geometry to the surface texturing. The included textures adapt automatically to the mesh deformation, maintaining consistent line markings and edge detail along curves. The system is designed to keep roads planar (flat), which simplifies viewport editing and avoids unexpected Z-offsets during extrusion. Users are reminded that vertical road modelling is unsupported—the surface will always remain level. The asset works in Blender 4.5 and is compatible with both Cycles and Eevee render engines. The creator explicitly recommends linking the asset library rather than appending, ensuring procedural dependencies remain intact when reused across projects.

Junctions and Lanes on Demand

One of the more technical features of Roads is its procedural junction generator. The setup automatically creates intersections for three-, four-, or five-way road crossings. The underlying node graph analyses connecting edges and merges topology to maintain correct lane and marking alignment. Lane count is also controlled via a single slider. Adding or removing lanes dynamically adjusts the overall width and marking patterns without breaking the underlying mesh continuity. All parameters are exposed in Blender’s Modifiers panel, allowing for live adjustments while modelling.

Workflow and Installation

Installation follows Blender’s current Asset Browser workflow. After extracting the Roads ZIP, users must register the folder in Edit → Preferences → File Paths → Asset Libraries, and set the import method to Link. In a new scene, a basic mesh (such as a plane) can serve as a starting object. Once all but one edge are deleted, dragging a Roads asset from the Asset Browser onto that edge instantiates the setup.

The developer suggests adjusting the Clip Start in the View panel to 1 metre for better visibility of painted lane markings. After setup, new roads are created simply by extruding the object’s vertices. Modifying parameters in the Modifiers panel allows fine-tuning of width, lane count, and material properties in real time.

License, Price, and Distribution

Roads is priced at $10 and distributed under a Royalty-Free licence through Superhive Market. The pluugin was authored in Blender 4.5, tested in Cycles and Eevee, and is classified under the platform’s Modifier Setups category. There is no external dependency, no installation script, and no Python component, which means the asset can be shared or version-controlled within production pipelines without modification.

Use Cases in Production

The tool is positioned for environment artists, level designers, and visualisation professionals who need rapid road layouts without external CAD or terrain plugins. Because geometry remains procedural, layout changes can be made interactively without reimporting or rebuilding the mesh.

However, since the asset enforces planarity, it’s best suited for flat terrains like urban scenes, car commercials, or realtime game prototypes where roads do not require elevation changes. The fully procedural texturing can reduce lookdev overhead, particularly in previs or real-time workflows where consistent UV alignment is required but manual texture painting is impractical.

What It Isn’t

Roads is not a terrain conformer, traffic simulator, or spline-based road network generator. It operates strictly within the Blender modifier system. The description on Superhive does not indicate automatic terrain adaptation or decal projection features. All intersections are handled within the node graph and remain 2D. As of publication, there is no mention of bridges, tunnels, or height-based modifiers. These limitations are inherent to its procedural design and must be considered during layout planning.

Testing Recommended

As with any procedural setup, users should test the modifier within their pipeline before committing to production scenes. Modifier behaviour can vary between Blender subversions, and procedural node setups occasionally differ when linked across projects. The developer’s documentation does not specify backward compatibility or version migration procedures.

Verdict

For ten dollars, Roads provides an elegant, minimalist solution for planar road generation in Blender. Its vertex-based extrusion workflow is immediately intuitive, while its reliance on procedural geometry and materials keeps files lightweight and editable. It won’t replace more advanced road tools that support vertical topology or terrain matching, but for quick previs, layout, or stylised city builds, Roads offers remarkable speed for minimal setup. As always, verify compatibility within your current Blender environment before use in production.

The post Procedural Roads Ahead: Blender Add-on “Roads” Lays Asphalt with Vertices first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

The Blender Foundation has released version Blender 4.5 LTS (Long-Term Support), the final LTS in the 4.x series, while the 2024 user survey sheds light on community needs, and the upcoming 5.0 beta offers a first look at the next major version.

Modelling, sculpting, and precision updates

A new Manifold Boolean algorithm replaces the old “Fast” option, providing much faster and more accurate results on watertight meshes. Snapping now respects the 3D cursor’s rotation, and objects can be parented to specific vertices without entering edit mode. Curves editing gains new operators, while the point cloud object type is now fully supported with its own edit mode. In sculpt mode, brushes such as Draw, Clay Strips, and Plain now respond to pen tilt, with Clay Strips around 22 percent faster.

Artists can mask by colour, and brush jitter controls for hue, saturation, and value have been added. Performance improves when using small brushes on large meshes. UVs can now be previewed in object mode, even across multiple selected objects — a small but meaningful workflow enhancement for texture artists.

Geometry Nodes overhaul

Geometry Nodes receives its biggest expansion since 4.0. There’s a new Set Mesh Normals node for manipulating tangent-space normals and storing sharpness data. Six new import nodes allow direct reading of external data types — OBJ, STL, PLY, VDB, CSV and TXT — and files can be dragged straight into the editor to create the corresponding nodes automatically.

Additional nodes include Match String, BitMath, and Camera Info, along with new field utilities like Field Average, Field Min/Max, and Field Variance. Geometry Nodes now supports drag-and-drop creation of input sockets from the sidebar and nested frame colouring for complex networks. Grease Pencil also gains three node types, Set Grease Pencil Colour, Set Softness, and Grease Pencil Depth, bringing 2D animation closer to procedural workflows.

Animation, rigging, and shape keys

Pose mode adds quick selection of children, parents, or siblings via Shift-G. Playhead snapping has been standardised across all timeline-based editors, including the Graph Editor and VSE. Keying Sets now behave consistently, and individual bones can override their display type. Shape-key workflows benefit from two long-requested tools: Duplicate Shape Key and Update from Objects, allowing direct refresh of multiple shape keys from mesh changes. Script authors should note an API rename from graph.keyframe_jump to screen.keyframe_jump.

Grease Pencil 3.0 integration

The version integrates Grease Pencil 3.0 more deeply with Blender’s render passes and compositor. A new Grease Pencil Render Pass enables per-layer compositing with proper alpha handling, and new supersampling anti-aliasing produces cleaner line art in final renders. Modifiers can now target specific layers or groups, and boundary strokes (Fill Guides) can be drawn interactively to close gaps during fills. Several legacy operators, including outline stroke generation, return for compatibility.

Rendering and lighting

Lights now include colour temperature and exposure controls, plus a normalisation option that keeps brightness consistent regardless of light size. The Cycles and EEVEE engines both gain a new Volume Coefficients Shader for physically accurate scattering, absorption, and emission.

EEVEE introduces shadow-terminator controls to fix self-shadowing on low-poly assets, a new reverse-Z algorithm for large scenes, and initial Vulkan backend support, offering smoother viewport performance and GPU subdivision.

Cycles receives a major boost to adaptive subdivision, now multi-threaded and roughly 10–15× faster. Normal-map filtering has been improved, and scripted OSL cameras allow physical lens simulation. AMD GPUs now use HIP ray-tracing acceleration by default.

Compositor and VSE improvements

The compositor now starts with a Viewer Node by default and can share compatible nodes with Shader and Geometry editors. A new Image Info Node exposes pixel dimensions; Relative to Pixel ensures resolution-independent blurs; and boolean inputs appear as checkboxes. GPU denoising and gizmos for Box and Ellipse Masks make compositing more intuitive.

In the Video Sequence Editor, playback performance is improved, metadata-rotated clips play correctly, and the Slip Tool is now smoother with synced keyframes. HDR previewing is supported, and several obsolete effects and the old cache system have been removed.

Asset browser, import/export, and file I/O

Screenshots can now be used as custom asset thumbnails with transparent backgrounds. Asset labels support multi-line text, horizontal lists improve node browsing, and import settings for geometry collections have moved to a central panel.

File import/export has expanded considerably: Geometry Nodes can now load and save PLY, OBJ, STL, VDB, CSV and TXT directly. USD import adds animated camera support, dome lights, and new primitives; FBX import is rewritten in C++ and is 3–15 times faster. GLTF export gains options for vertex colours, workbench materials, and AO baking.

UI and usability

Pen tablet support is improved with clearer region highlights, larger hit-boxes, and consistent pen-tilt response. Number-field scrolling now works on text boxes, and mouse-wheel fine-tuning behaves uniformly. The Outliner, Properties and Spreadsheet editors all received readability tweaks and new layout options. The light theme, icons, and scrollbars have been refined; Linux users get sharper Wayland cursors, macOS gets text-editing shortcuts, and Windows users will notice fewer white flashes during startup. On the housekeeping side, the developers confirmed that Intel macOS builds and COLLADA import/export are being deprecated. These removals simplify maintenance but may impact legacy pipelines. As always, Digital Production recommends testing the update in your own environment before deploying it in ongoing projects.

What the user survey reveals

The user survey is stil going – take part now!

Blender user survey 2025 – time to tell the team what you really think

What to expect in Blender 5.0 and the beta

Blender 5.0 entered public beta in October 2025. The current schedule foresees a release candidate around 5 November and a final release approximately a week later, on 11 November 2025. The beta already showcases some substantial changes to rendering, colour management, and user experience.

The most visible shift is expanded support for HDR and wide-gamut colour workflows, including improved ACES handling for compositors and colourists. Geometry Nodes continue to mature, with new modifiers, curve improvements, and better import support for external data. The user interface has been streamlined; over 300 theme settings were removed to unify the appearance and simplify customisation.

For technical directors, the key takeaway is that Blender 5.0 will mark a major version jump, and it may introduce breaking changes. Some add-ons and Python scripts may need updates to remain compatible. As of press time, not all release notes are complete, and several API changes remain undocumented, so early pipeline testing is strongly recommended.

What studios should consider now

For productions currently in progress, Blender 4.5 LTS should be considered the stable baseline. Its two-year support cycle makes it a safe anchor for long-term projects. Technical directors should also note the dropped support for Intel macOS builds and the gradual phase-out of COLLADA, to prevent unexpected pipeline breaks.

At the same time, teams can use the beta phase of Blender 5.0 to begin parallel testing. Doing so will identify add-on incompatibilities and prepare asset libraries for the Vulkan-based rendering core that will eventually replace OpenGL entirely. The Blender 2024 survey results offer valuable insight: stability is now the community’s strongest demand. Adopting the LTS version while cautiously evaluating 5.0 beta aligns with that philosophy.

The post Blender 4.5 LTS lands first appeared on DIGITAL PRODUCTION and was written by Bela Beier.