For those who don’t know the tool: Volume Forge is a volumetrics add-on for Blender that targets both Eevee and Cycles with localized light volumes and fog volumes.

What it is and what it builds

Volume Forge creates localized volumetric objects inside Blender. The intent is simple: place atmosphere only where it matters in the frame, instead of filling the entire scene with volume and then masking it back down. It is a faster and more practical path to focused volumetrics, with the additional claim that results often render much faster than physical fog applied across the whole scene. Each created volume is a mesh object with its own unique material, stored in a dedicated collection named Volume Forge. A created volume stays editable through the add-on panel rather than requiring manual rebuilding of the setup per scene.

The add-on workflow starts with four creation operators, then switches to editing controls once a valid Volume Forge object is selected.

Two volume types define shader behavior

Volume Forge exposes two volume types that differ at shader level. Light Volume uses an emission-driven volume. The store description calls it an emissive fake fog approach. The documentation describes it as usually faster to render and easier to push toward stylized light shafts, beams, and graphic atmospheric effects. The origin of this mode traces back to a widely used Blender trick: connecting an Emission shader into the Volume output, which can produce fog-like volumetrics that are often significantly faster to render than full physical fog.

Real Fog uses a Principled Volume shader and is intended for a more physically believable localized haze or fog response, including visible shadowing inside the volume. The documentation flags it as generally more expensive to render than Light Volume. Real Fog is not emissive, so it requires light in the scene to read clearly.

Two creation methods decide how geometry is generated

Volume Forge also splits creation by geometry construction. Cube is the fastest placement method. A Cube volume is created at the current 3D Cursor position, then behaves like a normal mesh object for transforms. Both Cube buttons follow this rule, and an unexpected placement typically traces back to the 3D Cursor location.

From Faces creates a volume prism between two selected quad faces. The prerequisites are strict: Blender must be in Object Mode, exactly two mesh objects must be selected, and each selected mesh must have exactly one selected quad face. If these conditions are not met, the operator stops and returns a warning instead of creating an invalid volume.

Selection order matters in From Faces workflows. The first selected object defines side A, the source side, and the second selected object defines side B, the target side. In typical Blender selection behavior, the second selected object is usually also the active object. This order defines an A to B direction used by the generated volume, including fade and spread behavior.

The prism generation reads the two selected quad faces in world space, reorders face B to best match face A, then generates the prism between them. If face A and face B do not match perfectly, the generated prism can differ slightly from the original B face. This is expected behavior, driven by a preference for planar faces to avoid twisted or deformed faces that can produce unstable volumetric results. Face B is adjusted as little as possible while keeping the generated volume clean and usable.

The four creation operators and their consequences

The Create section is always visible and shows two columns, Light Volume and Real Fog, each with Cube and From Faces options.

Create Light Volume Cube creates a mesh cube, moves it into the Volume Forge collection, assigns a dedicated Volume Forge material, and configures it in Light Volume mode. No object or face selection is required. This is positioned as a fast option for quick beam tests, early look development, and stylized shafts that do not need to be built between real surfaces. After creation, Cube-built objects expose the full Fade Direction control because the internal fade direction is not locked by geometry.

Create Light Volume From Faces builds a light volume anchored to scene geometry. It uses the two-object, two-quad-face requirement and the A to B selection order. The result is a prism between the faces with a dedicated Light Volume material, and the created object becomes the active selection. Fade Direction is hidden for these objects because it is locked by the A to B construction. Invert Fade remains available to reverse the internal fade without rebuilding the object.

Create Real Fog Cube creates a mesh cube at the 3D Cursor, places it in the Volume Forge collection, assigns a unique material, and configures it in Real Fog mode using a Principled Volume. The non-emissive nature of this mode means scene lighting becomes part of visibility. Cube-created fog objects keep Fade Direction visible, along with Fog Density, Main Color, Noise controls, Volume Shape controls, and Advanced Mask controls.

Create Real Fog From Faces builds a prism between two selected quad faces using the same A to B selection logic, creates a dedicated material in Real Fog mode, and selects the new volume for immediate editing. Like the light version, Fade Direction is hidden because it is locked by the A to B construction, while Invert Fade remains available.

Panel anatomy and what each section controls

Once a valid Volume Forge object is selected, the add-on panel exposes editing sections in a fixed order.

Selected Volume shows the active object name, the current mode, and a Viewport Wire toggle used to make navigation easier when a dense volume obscures scene context.

Mask and Falloff controls the internal fade and the overall mask. Fade Direction appears on Cube volumes and defines the axis along which the internal fade travels through the voluem. Fade Start controls where the visible fade ends. Invert Fade reverses fade direction without changing the chosen axis. Fade Interpolation controls the softness or sharpness of the transition between the visible side and the masked side. Edge Softness softens falloff near the volume boundaries.

Look controls the main visual response. Emission Strength exists only in Light mode and controls how much light is emitted inside the volume, with higher values making the light volume read stronger and denser. Fog Density exists only in Fog mode and controls the density of the localized fog volume. Main Color sets the main visible color of the volume.

Noise shapes internal variation and is positioned as essential for beams, broken-up shafts, and more organic fog. Noise Amount sets overall influence. Noise Global Scale sets the base scale of the Noise Texture. Noise Detail, Noise Roughness, and Noise Distortion provide procedural refinement. Noise Scale is a mapping scale vector, and reducing the Z component is described as a key technique for stretching the pattern along the volume length for longer god-ray style streaks. Noise Location moves the noise pattern in 3D space without moving the mesh. Noise Rotation rotates the noise pattern. Ray Spread opens or tightens the internal pattern along A to B travel. Invert Spread reverses the direction of the spread effect. Noise Animation animates the W dimension of the noise, with 0 keeping it static and positive or negative values moving it in opposite directions. Animated controls can be keyed directly when the small dot appears next to the parameter in the add-on UI.

Volume Shape controls tube-like rounding of the generated mesh through a non-destructive Bevel modifier. Enable Tube Bevel activates the modifier limited to relevant edges. Bevel Amount controls bevel width. Bevel Segments controls segment count. Clamp Overlap helps prevent problematic self-overlap when bevel becomes too large. Bevel Weight Direction appears on Cube-created volumes and changes which axis the bevel edge weighting follows. On From Faces volumes, the edges marked with bevel weight are the edges adjacent to the source and target faces.

Advanced Mask controls the tail end of the internal mask. Fade End controls where the fade reaches its end position. Shadow Color controls the color used on the darker side of the mask. Fade Start, Fade End, Main Color, Shadow Color, and Invert Fade together define how the volume transitions between a cleaner visible side and a darker masked look.

Marketplace details, compatibility, and licensing

The listing price is $19. The listing includes Blender Version 4.5 through 5.1, render engine usage in Cycles and Eevee, and license as GPL. The listing also states that future improvements are planned and that updates remain free for purchasers. Volume Forge is sold on Superhive.

New tools and innovations should be tested before use in production, especially when visibility depends on lighting, scale, render settings, and mask values that can shift between shots.

https://superhivemarket.com/products/volumeforge

https://depthoptica.com/docs/volume-forge/index.html

The post Volume Forge for Blender first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: Light Painter is a Blender add-on for lighting lookdev that paints onto a light texture in Cycles using Spot or Area lights, right in the viewport.

Setup: Cycles or nothing

Light Painter by ShaderError depends on Cycles light texture nodes, so it requires Cycles as the render engine. It does not support Eevee for this workflow. The baseline is Blender 3.6 through 5.1, and tCycles as the render engine and GPL as the license. Before you get excited and start scribbling highlights onto your hero asset, there is a short checklist that matters. You need a Spot Light or an Area Light, since the tool only works with those two light types. Point and Sun lights do not apply here, because the workflow relies on directional texture projection.

For sharper painting while you work, keeping the light size small helps. Spot Light uses a small Radius value and a Spot Size under 160 degrees to reduce distortion. Area Light uses scene scale dependent Size and a fairly low Spread value while painting. You can soften things later by changing Radius or Spread, but the painting stage favors crisp edges so you can read what you are doing.

The docs also recommend enabling GPU Compute for performance, since the tool relies heavily on shader computation. CPU rendering still works, but GPU is expected to be faster.

Painting on lights, not on meshes

The core idea is simple: you paint into a texture image that drives the light, and the tool previews the result in the viewport while you paint. You choose the target light in a panel, pick a texture resolution, and run a reset action that initializes the node setup. Then you paint using tools that include a brush and a gradient tool.

Light Painter stores the paint in a light texture image, with selectable resolutions from 512 pixels up to 4096 pixels. Higher resolution gives finer detail at the cost of more memory and slower interaction.

There is also a surface scoping system that controls what receives paint. You can paint on all meshes, a single object, or a collection. Separately, there is a skip list for objects that should behave as transparent for the painting depth pass, like glass windows, translucent curtains, fog and dust volume boxes, wireframe grids, and objects used for volumetric effects. If a see-through object blocks your strokes, it needs to be marked there.

Layers, masks, and the temp EXR stash

Light Painter includes a Photoshop style layer stack per light. Layers have blend modes, opacity, visibility, and transforms, and they composite from bottom to top. Blend modes listed in the docs include Mix, Multiply, Screen, Add, Subtract, Overlay, and Soft Light.

Each layer creates a Blender image datablock to hold pixel data. The layer system also writes temporary files to disk in the OpenEXR format to support undo, persistence, and compositing. These temporary files are cleaned up automatically when the add-on is disabled or when Blender closes, and layer metadata such as names, blend modes, order, and transforms is saved inside the blend file.

Layer transforms are non-destructive in light UV space, with offset, rotation, scale, and a pivot. The docs list shortcut gestures while the brush or gradient tool is active for moving, rotating, and scaling the active layer.

Selections add another control lever. You can build a mask to restrict painting so areas outside the selection are protected. The selection tool supports rectangle, polygon, lasso, and brush shapes, plus modes like add, subtract, and intersect. Expect to use this when you want to localize a fill or protect a face from accidental spill while you dial in a rim.

About that spill: the docs warn about light bleed beyond the painted region when the light source has a physical size. Blender can spread light beyond the texture boundary and into shadowed areas, and the current version does not compensate for that during painting.

Camera space vs light space

There are two paint spaces. In camera space, the paint is designed to match what you see on screen, with brush falloff mapping one-to-one with the viewport result. In light space, the brush math and gradient blending happen in the light texture space, while the brush centre and gradient endpoints come from the viewport, which can look distorted in the viewport depending on angle and distance.

Light space comes with two projection approaches for mapping the cursor. Raycast traces against geometry each frame and falls back when the cursor moves off surfaces. Plane establishes a paint plane on the first click, then projects subsequent cursor positions onto that plane. The gradient tool always uses raycast in light space.

This split is practcial. Camera space supports quick art direction because what you see is what you paint. Light space supports behavior that follows the light texture space more directly, and the docs describe it as a fallback for edge cases where camera space painting fails to cover some texels, such as steep angles or complex shadow boundaries.

Some studios will end up using both in the same shot. Start in camera space for broad strokes, switch to light space for the annoying bits, and remember that the annoying bits always find you in the final.

Preview and troubleshooting

The add-on includes a real-time overlay preview system. One mode previews only what is currently being drawn. Another mode overlays the full light texture and mask across the viewport and marks unpaintable areas in red, so you can see where the light reaches and where it is blocked.

There is also a preview option to show raw paint colour versus a falloff preview that includes rendering factors like distance attenuation and exposure. A light blur option attempts to mimic how Blender spreads the light based on the physical size of the source, with a multiplier to scale the effect.

If the result looks broken, reset the operator that rebuilds the shader node setup and resets layers. Changing light size can reset layers because the texture proportion ties to light size, and the docs recommend undo if the size change was accidental.

Advanced settings in the docs cover near and far clip for the light frustum, a surface bias for shadow acne, softness and bleed reduction controls, and internal capture resolutions.

Pricing and licensing

Light Painter is sold on Superhive in multiple tiers. LightPainter Lite is listed at $12. LightPainter for individuals is listed $36. LightPainter Indie for up to 3 people is listed at $80. LightPainter Full for up to 14 people is listed at $350. LightPainter Studio for 15 or more people is listed at $750. Currently there is a promotion that halves the prizes, no idea how long that goes.

As always, test any new tool and workflow in a controlled scene before it touches production assets, especially anything that rewires nodes, writes temp files, or changes how your lgiht setup evaluates across machines.

// Product page, pricing tiers, compatibility, license
https://superhivemarket.com/products/light-painter

The post ShaderError Light Painter paints light in Blender first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the thing: OpenPGL plugs into path tracing renderers to guide sampling. It already shows up in Blender via Cycles, and now lives under Academy Software Foundation governance for broader adoption.

A new home for guided rays

OpenPGL just became a hosted project under the Academy Software Foundation. It enters at the sandbox stage, which is the earliest entry point for young projects and comes with a stated goal of graduating to incubation within one year.

The project targets a specific kind of pain that every lighting TD knows by feel: path traced frames that need more samples because the sampler keeps spending effort in the wrong places. OpenPGL focuses on path guiding, an importance sampling strategy that uses additional information about a scene’s light distribution to make better sampling decisions. The result is higher rendering efficiency because the renderer spends more samples where they matter.

Path guiding has a deep academic history, but production teams rarely get value from a PDF alone. Integrating path guiding research into a production renderer can be tedious, and the implementation details often become a long-term maintenance tax. OpenPGL positions itself as a production-ready open source library aimed at lowering that cost by offering well-tested, robust implementations of state-of-the-art path guiding methods.

What OpenPGL actually does in a renderer

OpenPGL learns a representation of a guiding field during rendering and updates it on a per-frame basis using radiance and importance samples generated during rendering. During path generation, the renderer can query the guiding field at vertices along a path to get a local distribution that can guide sampling decisions, including which directions to pick next.

The practical promise is simple: better sampling quality, less noise, and more efficient renders for the same sample budget. The project also carries an explicit caution flag: its current versions are still pre v1.0, the API is still in flux, and it should be used with caution in production related environments. That is a polite way of saying the interface may change under you, so build your integration like you expect to revisit it. A lot. any times. Remember what you did for USD.

There is also a performance angle baked into the design. The implementation is optimized for recent Intel processors with SIMD instruction support listed as SSE, AVX, AVX2, and AVX-512. OpenPGL also states support for Linux, Windows, and macOS.

If you are the sort of person who reads build flags for fun, OpenPGL includes a CMake superbuild option that pulls dependencies and builds a full install directory. It can also build extra tools named openpgl_bench and openpgl_debug when enabled.

Who is already using it

OpenPGL is not arriving as an untested science project or white paper. It is already integrated into several big-name production renderers, including Blender’s Cycles, Chaos V-Ray, SideFX Karma, and Disney Animation Hyperion.

Disney Animation describes OpenPGL as an important building block in the second generation path guiding system of its Hyperion renderer, calling out a simple API and faster iteration on production challenges. The statement also says the studio used a new path guiding system using OpenPGL in the production of Zootopia 2, including shots with difficult lighting setups and complex volumetrics.

Illumination Studio Paris is using OpenPGL to bring advanced path guiding techniques into its production renderer in a robust and practical way, citing more efficient handling of complex lighting, reduced need for labor-intensive hacks, and more freedom for natural lighting setups. The statement also says OpenPGL proved especially valuable on its latest production, The Super Mario Galaxy Movie, for tackling challenging lighting scenarios.

Chaos describes performance gains in production scenes with complex lighting and calls the integration into V-Ray relatively straightforward. But V-Ray always has all the tools in it.

Governance, now with more grown-up shoes

As a sandbox project, OpenPGL is set up for open community participation under the foundation’s hosted-project framework. Separately, the Technical Advisory Council meeting notes for the project proposal capture additional context around the move, including that the proposal presentation was delivered by Sebastian Herholz, listed there as ex-Intel and soon Blender, and that the sponsor is Kimball Thurston at Weta.

The same meeting notes also include examples discussed in the proposal materials, such as comparisons showing less noisy results with path guiding enabled at the same samples per pixel, and an example that describes a V-Ray timing comparison of 50 minutes with path guiding off versus 34 minutes with path guiding on. Those examples are presented as part of the proposal materials, not as independently reproduced benchmarks here, so treat them as directional evidence rather than a guarantee.

Licensing, access, and the practical reality check

OpenPGL is released under the permissive Apache Software Foundation Apache 2.0 license. The code is available on GitHub, and the repository labels the current release as v0.7.1. The project is distributed as open source software under its stated license.

If you are considering bringing it into a pipeline, the most important detail is not the headline. It is the warning label: pre v1.0 and API changes are on the table. Plan for integration work, version pinning, and regression testing across scenes that stress your sampler. So, don’t put it into a production pipeline, and if you are writing your own render engine, please, be careful.

https://www.awn.com/news/academy-software-foundation-adds-openpgl-new-hosted-project

https://github.com/openpathguidinglibrary/openpgl

https://www.intel.com/content/www/us/en/developer/articles/technical/open-path-guided-rendering-made-easier.html



https://www.intel.com/content/www/us/en/developer/videos/path-guiding-with-blender-and-intel-open-pgl.html

The post OpenPGL joins ASWF first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: Nature Generator is a procedural asset library add-on that lives inside Blender via the Asset Browser and an N-panel, sold on Superhive Market, so you can kitbash nature without leaving your DCC.

The whole point is staying in your scene

Nature Generator builds natural assets directly inside Blender. Rocks, terrains, plants, water, and other environment bits all come in as editable, generated assets rather than fixed meshes. You drag an asset into the scene, the side panel recognizes it, and the controls you need show up without a detour to another app. The comparison to Quixel Megascans is obvious, being fully procedural and customizable.

The minimum version requirement is Blender 4.1 or higher. Hardware requirements call for a modern GPU from NVIDIA, AMD, or Apple Silicon. There is an optional texture options folder with 1K, 2K, and 4K texture resolutions. By default, the add-on uses low resolution preview textures, and the guidance recommends keeping the texture folder on a fast local SSD because it affects performance.

Installation stays simple. You drag and drop the zip into Blender, click OK, and the library sets up inside the Asset Browser. The Nature Gen panel appears in the side panel and opens with the N key. From there, drag and drop assets into the scene and start tweaking.

Geometry controls that reward restraint

Every asset follows a similar structure: shader settings and geometry settings, with slightly unique controls per asset. Geometry includes a resolution section, and most assets support a low-poly option. Viewport and render resolution can be controlled separately, and resolution can be subdivided or voxelized depending on the asset.

The documentation also includes the most honest feature statement possible: resolution can go infinitely high, and every asset can crash Blender if you push it too far. That makes the control powerful, but it also makes self-control part of the user interface.

Base shapes come from primitive forms you can alter in edit mode. Some assets follow the structure of a mesh and react to topology. Some are planes. Some are driven by curves. Displacement settings include multiple texture and noise displacement controls, with patterns such as noise breakup, stratification lines, and crack patterns. Many categories expose basic settings and an advanced subcategory for deeper tuning.

At around the moment you start dialing prcoedural detail like it is free, that crash warning stops reading like documentation and starts reading like prophecy.

Custom shaping can use a gradient with its own displacement, falloff, location, and scale settings, with viewport gizmos available when the modifier is selected. Alternatively, a custom curve object can influence the terrain, with a radius setting and a distance based falloff where farther from the curve means weaker influence. A secondary custom shape can be added, such as one curve for valleys and another for mountains.

Scatter was rebuilt to be more direct

The latest update changes how the scattering system works. If you have an older version, the update workflow shown is to download the new version from Blender Market and drag and drop it into the scene so it overrides the old version.

The new scatter setup aims to be simpler with fewer settings. The key change is the import flow. You import the specific assets you want to scatter, then assign them into the scatter collection. After importing, you can toggle an exclude option so the collection does not sit visibly in the scene, while still being used by the scattering system.

Core scatter behavior remains familiar. You can adjust density, and you can still use slope based scattering, altitude based scattering, and noise based scattering. Scatter zones remain part of the tool, controlled by empties with viewport gizmos so you can define a local area for scattering.

The update also introduces threshold softness controls across settings. The stated purpose is scaling down scattered assets toward the edges of masks. That creates a smoother falloff where a hard cutoff would look like a stamp.

Draw where the scatter goes

A major addition in the update is a scatter curve or grease pencil option. You can assign a curve or a Grease Pencil object and use it to decide where scattering appears and where it does not.

The workflow shown is straightforward: create a blank Grease Pencil object, draw directly on the surface, then select that drawing as the scatter guide. The same idea works with a curve object. You get controls for draw radius and radius softness, and the falloff scales down scattered assets toward the edges. There is also a noise option to distort the shape and avoid a too clean, too perfect outline.

Remove the draw object, and scattering returns to the default behavior. That makes the feature easy to test and easy to abandon if a shot changes direction.

Viewport survival mode, now with choices

Scatter can get heavy. The update adds a display mode control in the instance settings. You can display instances as originals, as boxes, or as wire box. Instance scale stays, but the update adds a secondary scale and a secondary scale probability. That lets a minority of instances become much larger than the rest, adding variation without requiring a second scatter layer. Rotation controls remain.

There is also a new wind animation option for scattered assets. Wind time is a value you animate, with an example workflow of adding a driver expression using hashtag frame and optionally dividing to slow it down. The update explains why this stays manual: using a scene time node inside node trees made performance drop sharply, including an example of frame rate dropping to around seven. Removing the time node restored smooth playback. With many scattered objects each carrying the scatter system, the update keeps wind time explicit to protect performance.

Terrains, water, and the new step look

Terrain and mountain assets use a separate X and Y resolution, because resolution on those axes influences the shape and form of erosion. Terrain maps include a random seed, and terrain can generate from noise or be influenced by a custom shape.

Noise displacement includes control over influence on X, Y, and Z, plus a noise seed and standard noise settings. Texture displacement adds rock detail. Erosion settings apply erosion from a selected height, with placement, falloff, and an option that can add mountains and inverted valleys. Boundary falloff can flatten edges.

Water effects add a cube with a procedural water shader. Controls include height and depth, and rivers can be created by combining a water effect value with custom curve shaping that pushes terrain down so water appears in selected areas. Water shader settings appear in the shader tab, including animated noise controls to create the illusion of moving water with separate speed controls on X and Y.

The update adds terrain presets, including a forest preset and a canyon preset. The forest preset uses the scattering system, and trees can default to box display for performance on lower-end systems, with the option to switch back to originals. The update also adds a terrain steps feature on some presets, described as a stepping effect. Controls include the number of steps, detail, strength, and blur, with noise-based selection and influence. Terrain steps can be found in erosion settings, in noise settings, and when drawing along a custom curve.

Trees arrive, and snow gets more physical

The update adds tree assets. Tree shaders follow the same structure as flowers, including leaf color controls and translucency. Leaves can be pushed toward an autumn look by changing colors. There is also a setting for a leaf mask, and leaf shapes are generated procedurally, with controls for scale and mask threshold.

Scatter categories shown include plants such as flowers, wheats, grass, ground cover, shrubs, plus rocks, snow, and trees. Scattered rocks are procedurally generated and have their own settings such as resolution, shape distortion, size ratio, and a seed.

Snow scattering gets a notable twist. Importing a snow object can be recognized and turned into a volume style approach for creating snow on objects rather than only shader based snow. Snow settings sit in the geometry tab, including resolution and displacement settings. Particle detail adds small particles with alpha textures, intended to improve realism for close-ups. The tool also notes that foamy snow detail may require higher transparency bounces.

Materials, uniqueness, and the new override option

Materials are shared by default. The tool includes Make Material Unique to create a new copy of a material for the selected object, and Revert to return to defaults. The update also adds a use custom material feature for the new scatter effect. The workflow shown duplicates a material and assigns it as an override for the scattered assets, so you can make unique changes without affecting the original material used elsewhere.

Scatter effects can stack, and the update shows renaming modifier labels to organize multiple scatter effects. This is the part where it starts feeling less like an asset pack and more like a small ecosystem.

Pricing and what is actually specified

Pricing is specified on the product page. A Personal License costs $99. A Commercial License costs $169. A Studio License costs $259.

https://superhivemarket.com/products/the-nature-generator?ref=586

The post Nature Generator update brings procedural nature to Blender first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: Real Caustics is a Blender add-on that bakes caustic textures for scenes, then you can carry them into a USD pipeline without dragging your render engine into a fistfight.

The pitch, minus the pool noodles

Caustics are the moving light patterns you see under shallow water, like on a pool floor or riverbed. Real Caustics is an add-on for Blender that targets that exact look, with a workflow built around animated water surfaces. It is designed for fluid simulations, ocean modifiers, dynamic paint, and any mesh-based water surface, with the pattern tracking the surface shape frame by frame.

The product page states a clear intention: stop faking caustics with video textures or noisy approximations, and generate patterns that follow the water motion instead. That is a creative goal, not a standards document, but it sets expectations for what the tool tries to automate.

One noteworthy disclosure sits right on the page: development used AI coding tools, while the author directed and validated the technical decisions, node structures, interaction logic, and tests.

Bake once, keep your renders on a diet

Real Caustics generates caustics as textures that get baked. The claim is that once generated, they add zero overhead to your render, since the heavy lifting happened during baking. The workflow is hands-on and iterative: Generate Current Frame writes a texture, reloads it, and shows it in the viewport in seconds. After you like the look, you generate the full sequence and render.

That bake-first approach matters for production planning. It shifts time from per-frame render cost to a preprocessing step you can schedule and version like any other cache. The baked output also means the textures can be used in any render engine, since they are just textures at that point.

In practical terms, this is the difference between fighting caustics every frame and treating them like any other animated texture sequence. If your waetr surface changes, you regenerate. If lighting changes, you may need to rebake depending on how you set things up.

Controls that aim at art direction

The add-on includes settings intended for look development. The product page describes intensity control independent of the light and water mesh. It also describes generating caustics straight from displacement and bump rather than relying on geometry density with smoothing patterns, adding dispersion, and a tiling mode for generating seamless textures, with the condition that the input geometry tiles reasonably.

When enabled, generation reads shader-based displacement and bump maps so the caustics follow the generated normals of the water, not just the base mesh. You can get the best results when a simulation generates real geometry while shader bump adds smaller detail waves.

Real Caustics is designed and optimised for water surfaces, but it maybe can produce interesting results with other glass objects, but it only accounts for a single ray pass. It explicitly states there are no internal bounces, depth variation, or IOR changes as rays are traced through geometry, and that standard path-traced methods give more accurate results for realistic glassware and gemstone caustics.

Engines, versions, and the part where you avoid surprises

Real Caustics generates caustic textures using both Cycles and Eevee. Since the output is baked textures, it can be used in any render engine. It also calls out USD workflows: you can generate textures in Blender and bring them into other software.

The listing specifies support for Blender versions 5.0 through the most recent 5.1 release, and the FAQ warns that after an update, you should check supported versions if something breaks.

There is also a specific setup constraint worth flagging for shot assembly: nested collections inside the Water Collection are not supported, only direct object members are supported, and collection instances will not work either. If you have a scene-building habit of nesting everything, this is the kind of detail that can quietly derail a bake until someone notices.

Caustics Energy Fix limits caustic intensity when light passes through multiple overlapping surfaces to prevent overbright artefacts, and it must be plugged in after the caustics texture.

Caustics Water is a pre-built Mix Shader combining Transparent BSDF, a surface shader input, and an Is Shadow Ray condition, handling the complete shadow ray setup in a single node.

Documentation also describes a Rebuild Node Groups function that reinstalls shader node groups into the current scene and overwrites node groups with specific names, advising you to rename node groups or create non-instanced duplicates if you want to keep older scenes working as-is. That detail is a polite way of saying version management still matters even when the UI looks friendly.

Pricing and licensing, spelled out

The listing includes multiple purchase tiers. The Individual license is priced at $30 and includes the add-on with full functionality plus a pack of pre-baked textures. A Studio option for up to five users is priced at $50. A Studio Pro option for five or more seats is priced at $70. There is also a Pre-Baked Textures product – a pack of 10 pre-baked animated textures that are seamless and looping, priced at $5.

As always with new tools, test in a staging scene before you roll anything into production, especially when re-baking sequences and updating node groups can change reuslts across shots.

https://superhivemarket.com/products/real-caustics

The post Real Caustics for Blender first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Procedural Clouds plugs into Blender as a volumetric sky builder aimed at Cycles, letting you rough in atmosphere during lookdev before lighting turns everything into a science project.

How?

Procedural Clouds exposes its controls in the N-panel, so you can steer the setup without opening node graphs. That matters in production because fewer accidental edits land in the wrong graph at 2 a.m.

Solid Preview is the key switch for fast iteration. Turn it on and the clouds show up in Solid mode. There is also an auto mode that watches viewport shading and toggles Solid Preview for you, keeping it off in Rendered mode and on in Solid mode.

The add-on also includes a Pin system that locks the UI to a target object so the controls keep talking to the right volume even when selection gets messy. Pin Auto Switch exists as a preference and is enabled by default, letting the pinned target follow the currently selected supported object. Turn it off and the pin stays glued to the original target.

Scene tweaks you should notice before they bite

Some features can automatically adjust Blender scene settings during use, including volume bounces, step count, and clip distance. If you want your scene settings left untouched, you need to disable those options in the add-on preferences or dial them back.

Clip Start and Clip End are specifically called out for Solid Preview artifacts. If the volume looks sliced or flickers, raise Clip Start. If the cloud gets cut off in the distance, raise Clip End. You also need to set matching Clip Start and Clip End values on the scene camera.

Made by Suzanne studio, the docs also flag that Blender 5.0 changed the algorithm for Voronoi Texture, so presets can look slightly different between Blender 4.5 and 5.0 even when the cloud remains the same and the seed changes.

Scaling rules that keep the look consistent

The scaling behavior is split by mode. Scale in Object Mode and the object changes size without changing internal settings, so the effect parameters stay the same and the visual result stays consistent. Scale in Edit Mode and you change the underlying volume or mesh size, extending the existing content while keeping internal settings and detail density stable.

The recommended starting point is a cloud object around 2 meters, then resizing in Object Mode. After extreme scaling, you may need to adjust Density to get the result back to where you want it, especially if your cluod suddenly looks like it went on a diet.

Knobs that trade detail for speed

Three controls define the look to cost relationship. Point Density controls how full the cloud is. Higher values produce thicker and more detailed clouds, while lower values produce lighter clouds and faster performance. Point Size Min and Max control variation in the cloud shapes. Higher values push softer and puffier shapes. Lower values push finer structure. Volume Resolution controls the final detail of the volume. Higher values sharpen detail but slow things down. Lower values render faster with a softer result. That resolution knob is also where perofrmance usually goes to negotiate for lunch.

Keeping your scene clean while you iterate

Make Unique creates an independent copy of a selected object so changes do not affect others. It is built for the classic moment when you duplicate a cloud, tweak it, and discover you just changed every cloud in the shot.

There is also a note about removing a Boolean Empty cleanly. Deleting the Empty in the viewport may leave it in the scene, so removal can require deleting it from the add-on panel or deleting it in the Outliner.

New tools and innovations should be tested before use in production, especially when they can touch scene settings and when shot continuity depends on repeatable volumetrics.

https://superhivemarket.com/products/procedural-clouds/

https://www.youtube.com/@suzanne_studio3d

Licensing and tiers

Pricing is tiered into three licenses, all of which include creator support and future updates.

The Personal tier costs $25 and is for personal or non-profit projects.
The Commercial tier costs $45 and is for commercial projects.
The Studio tier costs $110 and is a multi-seat license. It also lists custom features request alongside creator support and future updates.

The post Procedural Clouds with Cycles focus first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: glTF sits between DCC export and runtime playback, and these web tools help you sanity check assets and rendering across engines before shots get spicy.

Two sites, one mission: fewer surprises

The glTF Sample Assets site and the glTF Render Fidelity Comparison site just got meaningful upgrades. They target the same everyday pain: you export a model, it looks right in one viewer, and then it looks slightly off somewhere else where it matters. The refreshed Sample Assets experience focuses on browsing, filtering, and sharing reference models that exercise specific features of glTF. The updated Render Fidelity Comparison experience focuses on visual baselines, with side-by-side checks that make renderer differences harder to hand wave and easier to track down. If you build tools, ship engines, validate exporters, or wrangle assets for realtime and VFX, these sites are designed to be the boring, reliable kind of helpful.

Sample Assets gets a real front door

The new landing experience for glTF Sample Assets presents the repository as a proper website. The intent is simple: make it easier to browse and find models by what they demonstrate. Models appear with thumbnails, and animated assets include a small animation preview. The site supports light and dark themes and aims for fast loading and fluid navigation. Filtering and search are first class, with tags that map to features, functionality, and extension coverage.

When you open a model, you land on a dedicated model page with an interactive preview, metadata, and download links. The preview uses the glTF Sample Renderer, which is built on WebGL and targets correct support for official KHR extensions. A context menu in the preview provides presentation options that include debug visualization modes for material properties, variant selection when multiple variants exist, and wireframe presentation when the WEBGL polygon mode extension is available.

The model page also links out to external tools and shows a recommendation style list of related assets, which is a surprisingly effective way to bounce between test cases when you are chasing a specific shading edge case across multiple files.

One practical detail matters here: each model includes a screenshot, description, license information, and a live preview. That combination turns the site into a quick reference shelf rather than a scavenger hunt through folders.

Render Fidelity Comparison leans into side by side truth

The redesigned glTF Render Fidelity Comparison site takes the same library mindset and aims it at output consistency. It frames the core goal as convergence around physically based rendering materials so you can expect a model to appear as intended across renderers and lighting environments. It also notes that this is ambitious, with realtime rendering quality still changing rapidly. *cough* understatement *cough*

The workflow is built for quick comparisons. You choose a model, filter by tags or search, then pick two renders and select a view mode. The comparison modes include side by side viewing, a slider view, and a difference view that shows computed differences.

The site spans popular realtime web renderers and also includes path tracers. In practice, that means you can jump between quick interactive engines like babylon.js and three.js, then also look at path traced production renderings from Blender using Cycles and from V-Ray. It is not about crowning a winner. It is about seeing where two implementations diverge so you can reproduce, triage, and fix.

Comparison images are generated offline and submitted via pull requests to the site repository, which keeps the content auditable and repeatable. That approach also makes it easier for teams to add coverage for their own renderer outputs without inventing a new pipeline.

The biggest new trick is an experimental 3D comparison mode that enables full interactivity comparison of two realtime renderers side by side. It currently supports three.js, babylon.js, model-viewer, and three js path tracer tooling. If you have ever tried to discuss a subtle lighting mismatch over screenshots, you know why interactive side by side matters. In one sentence, the updated site encourages you to comapre outputs with fewer assumptions and more pixels on screen.

https://github.khronos.org/glTF-Render-Fidelity/model/AttenuationTest

Contributing is part of the design

Both sites are open to contributions. For sample assets, new models can be proposed via pull requests to the repository. For render fidelity, you can submit renderer outputs by following the repository guidelines for generating renders of a sample asset and placing the results in the appropriate location for comparison.

There is also a straightforward feedback loop via issues in the repositories, which keeps bug reports and feature requests attached to something actionable. This is the one place where it is worth naming the organizer exactly once: Khronos is clearly aiming to make the glTF developer ecosystem easier to navigate, easier to test, and harder to break quietly.

https://github.khronos.org/glTF-Assets/

https://github.khronos.org/glTF-Render-Fidelity/

The post glTF sample assets and fidelity site refresh 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.

The free Blood Hit 3D Asset lands as an Alembic animation, pre-simmed and intended to drop straight into a project. That matters because it keeps the asset squarely in the world of import, shade, light, render, comp, rather than asking you to set up a fluid sim, cache it, and hope your deadline shows mercy.

The asset targets broad compatibility by leaning on Alembic, a format widely used for baked geometry animation interchange. The file is positioned as something you can use in almost any render engine or 3D app, as long as your toolchain can ingest Alembic and you can assign materials the way you like.

This is very much a VFX elemnet style freebie in spirit, but it ships as 3D animation rather than a 2D flipbook or a stock plate. You get geometry motion you can place in space, aim at camera, frame with lens choices, and match to lighting cues. The messy bit becomes a scene object, not a comp sticker.

Two quality tiers, one timeline, and a choice of speed

The download includes two quality versions: a lower-quality option for faster renders and a high-quality option for hero shots. The animation runs at 24 fps, keeping it aligned with common editorial timelines and shot contexts.

There are also two speed options: a base speed described as slow motion and a fast speed option. Practically, that gives you two starting points for timing without forcing you to retime a single cache into wildly different beats right away. If the shot needs a long, readable splatter moment, the base speed exists. If you need a sharper hit that sells impact and gets out of the way, the fast option exists.

Because this is a pre-simmed Alembic cache, your artistic control flows through placement, scale, camera distance, shading, motion blur choices, and render settings. Your control does not flow through sim parameters, since the simulation work is already baked.

Where it plugs in across engines and DCCs

The broader compatibility pitch comes with specific examples of tools and engines that can be used with the paid pack the freebie points toward. The supported examples include Blender, Houdini, Unreal Engine, Arnold, V-Ray, OctaneRender, Redshift, and Cycles.

That list spans both DCC hosts and renderers, which is a useful reminder of how Alembic assets tend to travel in real productions. Sometimes you import into a DCC and render there. Sometimes you import into a DCC and export again into another context. Sometimes you bring it straight into a real-time environment like Unreal Engine for previs, cinematics, or interactive content, then either render there or use it to inform final lighting and comp decisions elsewhere.

If your pipeline already handles Alembic caches for crowds, cloth, or destruction, this should feel familiar: it is another baked motion asset you treat like a shot-specific prop. If you are new to geometry caches, the main idea remains simple. Import the cache, scrub it, and make sure it lines up with your timeline and scale before you start shading and lighting.

How you actually get it

Access to the free Blood Hit 3D Asset requires joining a newsletter, after which an email provides download instructions. If you are already on the newsletter list, previous emails are described as containing the same download instructions. The freebie is also positioned as part of a larger library described as 500+ other free 3D freebies. That bundle access is tied to the same newsletter workflow, rather than a one-off anonymous download link.

If your studio policy treats marketing email lists as a procurement step with paperwork attached, that is the moment to loop in whoever manages vendor communications. If you are an individual artist, it is simply a question of whether you want the asset enough to do the email round trip.

The paid pack it points to, and what it costs

The free asset sits alongside a commercial product called VFX Elements Volume 03: Blood Hits. That is containing 25 blood hit animations, delivered as Alembic files intended to load into render engines and 3D apps that support them. The listed price for the pack is $69.00, and it is as an instant download. The same engine and application examples show up here as well, including Blender, Houdini, Unreal Engine, Arnold, V-Ray, OctaneRender, Redshift, and Cycles. The pack is also shown with low-resolution playblasts used to preview the animations. That detail matters because it frames expectations: previews exist to show motion, but you should still evaluate how the cache behaves in your own render context, shading approach, and lighting setup.

Any new asset needs testing before you drop it into production shots. Import it into a sandbox scene first, confirm the scale, check frame-rate alignment, and verify how your chosen renderer handles motion blur on geometry caches. Do the same for both quality versions, because render cost and cache behavior can differ in ways that only show up once you hit real lighting.

Shading is the other big practical checkpoint. A blood hit cache does not automatically become convincing just because the animation looks good. You still need materials, spec response, and lighting that sell wetness and thickness. Your comp workflow also matters, especially if you plan to integrate the hit with interactive lighting or lens effects. This freebie gives you motion, but the final look still lives in your scene setup.

The Pixel Lab appears to be using this free Blood Hit 3D Asset as both a standalone giveaway and a doorway into the larger VFX Elements Volume 03: Blood Hits collection. If the one free hit covers your immediate need, great. If your work calls for a variety of impacts and angles, the 25 animation pack exists with a clear price tag and the same Alembic foundation.

https://www.thepixellab.net/free-vfx-element-blood-hit-3d-asset

The post Pixel Lab drops free Blood Hit Alembic 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.

For those who don’t know the tool: The PBR Asset Browser by Can Of Textures is a material library sold via Superhive for use inside Blender’s Asset Browser, targeting Cycles and Eevee users who want ready-built surfaces.

The 5000 PBR Asset Browser packages more than 5000 physically based rendering materials into a Blend file configured for Blender’s native Asset Browser. The library is organised into 13 categories including bricks, wood, fabric, metal, plastic and tiles.

Each material includes standard PBR maps. You’ll get Base Color, Roughness, Normal and Displacement maps, with Metallic and Opacity maps where required. Textures are supplied at 2K resolution in JPG format.

The workflow is deliberately simple. Users extract the archive, open the provided Blend file, and access the materials via drag-and-drop in their own scenes. No addon is required. No external asset manager is referenced.

The materials are compatible with Blender’s Cycles and Eevee render engines. In addition to the prepared Blend file, the pack includes individual texture folders, allowing manual setup in other tools such as Unreal Engine and Unity.

Organisation into category folders is presented as a way to keep Blender responsive by limiting the number of visible assets at a time. The materials are offered under a GPL licence, with the product page stating both personal and commercial use are permitted.

At the time of writing, the complete version is shown on Superhive in a range of approximately USD 18.75 to USD 25 depending on discounts. No subscription necessary!

The value proposition is scale and convenience rather than new shading technology. More than 5000 2K PBR materials, pre-organised for Blender’s Asset Browser, at an indie-friendly price point. As always, new tools and libraries should be tested before deployment in production environments.

https://superhivemarket.com/products/5000-pbr-asset-browser

The post 5000 PBR materials, zero node wrangling 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 know the site: Kitbash3D makes themed 3D environment kits for VFX, games, and visualisation. The new New Delhi Kit joins their growing library of ready-to-use digital worlds, compatible with most major DCC and realtime tools.

City without chaos

Kitbash3D has released New Delhi, a detailed collection of 3D assets designed to recreate the layered architecture and street textures of India’s capital. The kit includes 84 models and 127 PBR materials, intended for artists working in VFX, games, animation, and visualisation. The collection mixes colonial-era façades, contemporary concrete towers, and dense market alleys. Kitbash3D states that the assets are built for “realistic, lived-in environments” and are designed for both large-scale cityscapes and street-level storytelling.

Compatible across pipelines

The New Delhi Kit is supplied in standard formats, including FBX and USD, and integrates with major DCC tools such as Blender, Maya, and 3ds Max. It is also compatible with realtime engines such as Unreal Engine and Unity, and supports common renderers including Arnold, Cycles, and Redshift.

Kitbash3D lists the kit as ready for immediate production use, with pre-optimised geometry and consistent scaling for modular assembly. The files use standard PBR workflows and are organised for straightforward import and texturing.

Architectural detail and reuse

According to the official description, the New Delhi Kit focuses on flexibility and reusability. Building assets can be mixed to create anything from residential areas to commercial centres. Street props, market stalls, and signage extend the set for scene dressing or background population.

The kit is part of Kitbash3D’s ongoing series of geographically themed city kits, following earlier releases such as Tokyo, Paris, and New York. The New Delhi collection adds a South Asian context to the library, expanding possibilities for worldbuilding and localisation in cinematic and interactive productions.

Available now

The kit is available for purchase directly from Kitbash3D. The New Delhi Kit is included in Kitbash3D Unlimited, the company’s annual subscription giving full access to its 3D asset library via the Cargo desktop app. Unlimited costs USD 995 per year for individual freelancers and USD 3,995 per year for small studios with up to 50 employees. Assets can be used in active productions during the subscription, but new projects require an active licence. Perpetual rights are available separately for specific kits.

Artists are advised to test the assets in their own production setups before integrating them into active pipelines, particularly when mixing renderers or real-time and offline workflows. A quick inspection of the models suggests consistent texutre naming and clean geometry, but the actual level of optimisation can vary depending on import method and scene scale.

https://kitbash3d.com/products/new-delhi

The post Delhi in 3D: Kitbash3D goes urban first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: Poser 14 is Bondware’s long-running 3D character posing and animation package, first released in 1995 and now mainly used for illustration, comics, and previs. It provides rigged figures, props and render engines like SuperFly and FireFly.

A venerable poser returns (and we almost missed it)

In the festive mail avalanche, we briefly lost sight of one of CG’s oldest names. Bondware quietly shipped Poser 14 in late November 2025. We only noticed now, and the fault is entirely ours. Missing a veteran like Poser feels mildly sacrilegious, so here’s a proper look at what’s new and what’s missing.

The update in short: simpler materials, tidier backgrounds

Poser 14 focuses on usability rather than expansion. The release adds a reinstated Simple Material tab to the Material Room, designed to simplify PBR (Physically Based Rendering) workflows. Artists can now drag texture maps exported from tools like Substance Painter directly into the interface, skipping the former multi-node complexity.

A new Simple Background tab consolidates scattered controls for environment setup into a single location. Users can choose from four background types (colour, static image, movie, or HDRI environment) with a real-time HDRI preview now built in.

Rendering: updated SuperFly and Intel Arc support

The SuperFly render engine has been updated to the latest stable version of Cycles, providing improved ray tracing stability and compatibility with Intel Arc GPUs through Intel’s OneAPI framework. FireFly Renderer remains available for compatibility with legacy scenes, alongside non-photorealistic render modes such as Cartoon, Comic Book, and Sketch.

Goodbye Cloth Room (for now)

The most visible removal is the Cloth Room, the long-standing simulation module for dynamic clothing. Bondware acknowledges the change directly, advising users who depend on cloth simulation to continue with Poser 13. According to the developers, new simulation options are being investigated, and a return of cloth dynamics is on the roadmap, but without a timeline so far.

Platform changes and pricing

Poser 14 is now Windows-only. The macOS edition has been discontinued, with Bondware citing a desire to “streamline” development toward the majority user base. The simplification also extends to pricing: the full licence now costs 175 USD (down from 199 USD), while upgrades from Poser 11, 12, or 13 are available for 99.95 USD. A 21-day free trial version is also provided.

Compatibility and legacy features

Poser 14 retains Python scripting, support for LaFemme and L’Homme figures (versions 1 and 2), HiveWire3D content, and render layers in FireFly. The internal content library continues to ship with over 30 GB of bundled figures, props and environments. System requirements list Windows 10 or later (64-bit), 16 GB RAM, and an OpenGL-capable GPU. CUDA and OptiX are recommended for GPU rendering.

Poser 14 in context

After three decades, Poser remains one of the few dedicated figure-posing environments not tied to a larger DCC (Digital Content Creation) suite. The latest release suggests Bondware is favouring long-term maintenance and accessibility over feature expansion. Whether that approach will restore Poser’s relevance against free alternatives like Daz Studio remains to be seen. Still, the team’s willingness to cut complexity may please those who simply want to light, pose, and render without fighting their tools. As always, artists should test new releases thoroughly before introducing them into production pipelines.

The post Poser 14 drops Cloth Room, gains simpler PBR setup first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Antoine Bagattini, the creator of BagaPie has released BagaCam OSL, a camera add-on that implements Open Shading Language (OSL) camera shaders directly in Blender. It runs within Blender’s Cycles render engine, allowing users to apply and customise optical effects directly at render time rather than in compositing.

The add-on introduces a OSL-driven camera system, allowing effects to behave as part of the physical light simulation. Because the shaders influence ray casting rather than pixels, they interact properly with volumetrics, transparency, motion blur, and reflections, behaviours typically missing from post filters.

Built-in optical effects

BagaCam OSL ships with a preset browser containing camera looks based on real lens artefacts. Included effects are barrel and pincushion distortion, chromatic aberration, vignette, glow, and several depth-of-field variations. The system also supports custom bokeh shapes, including anamorphic and petzval patterns, directly within Cycles.

Each camera in Blender can hold its own preset. When switching between presets, parameters reset to their default values to maintain consistency across scenes. Advanced users can access the raw OSL shader parameters to tweak the optical model beyond the preset limits.

OSL under the hood

Open Shading Language (OSL) is a shading language designed for physically based rendering. Cycles’ OSL implementation lets artists define shaders that describe how rays behave rather than how pixels look. BagaCam OSL uses this system to make the camera itself a shader, modifying how rays are projected into the 3D scene. This allows, for example, a chromatic aberration shader to refract light in the ray-tracing step, rather than faking it afterwards in compositing. It also means depth-of-field and motion blur remain physically consistent because they occur at the render stage.

Limitations and requirements

BagaCam OSL currently works only in Cycles. Eevee and Eevee Next do not support OSL camera shaders. GPU OSL rendering is limited to single-GPU setups, and CPU rendering remains the most stable mode for complex OSL operations. The add-on targets Blender 5.0 and later. Pricing details are listed on the Superhive product page. It’s 12 USD.

Why this matters

Integrating optical simulation at the camera stage allows for physically plausible renders without relying on external compositing. For production workflows requiring realistic lenses or cinematic depth, BagaCam OSL offers a direct, render-level alternative to Nuke or After Effects lens filters. Artists working on VFX, archviz, or animation projects can now match real camera characteristics within Blender’s render itself, with fewer steps between shot design and final comp.

As with any new tool, it should be tested on production scenes before adoption, especially when combining OSL with complex shading networks.

The post Blender Gets Real Lenses: BagaCam OSL Released 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.

Hothifa Smair, known for iCity and iCars, has released iCrowds — a full-featured crowd simulation system for Blender 4.5 and newer. The add-on targets film, games, architectural visualisation, and urban design, offering seven integrated systems for both static placement and dynamic movement of thousands of autonomous agents.

Seven Systems for Every Scenario

iCrowds divides its toolkit into static and dynamic subsystems.
The static systems provide surface, curve, vertex, and structured venue distribution.
The dynamic systems introduce motion, pathfinding, and crowd intelligence.

The core modules are:

• On Ground System: Scatters agents across terrain surfaces using vertex group masking, density gradients, and natural variation noise. Supports both single agents and cluster formations.
• On Curve System: Generates linear distributions along user-defined paths with width control, automatic orientation, and curve radius–based density scaling.
• On Vertex System: Enables precision placement on mesh vertices for architectural and design layouts, supporting weight painting and group-based patterning.
• Stadium System: Builds structured seating or audience arrangements, with grid controls for rows and columns, and alignment parameters for rotation and orientation.
• Walkers System: Simulates organised pedestrian flows along curves with bidirectional traffic, lane control, and personal-space handling.
• Fluid System: Adds real-time dynamic behaviour with physics-based attraction, repulsion, and path following. Agents react to scene elements and adjustable flow fields, suitable for events or evacuation simulations.
• City System: A full urban AI layer inspired by games like The Sims. Agents respond to internal needs—hunger, rest, fun, or bladder—and navigate to context-appropriate locations (restaurants, homes, toilets). Debug tools permit real-time inspection of individual agent states.

Performance and Scalability

The developer states that iCrowds supports up to 100,000 agents, depending on hardware and scene complexity. It includes LOD (Level of Detail) options for real-time performance, and baking tools to commit simulations for render-heavy scenes. The add-on uses efficient memory management for scaling from architectural previews to large film visualisations.

Characters and Customisation

The package provides 10 human base models in high- and low-poly variants, available in multiple outfits. Clothing options include formal, casual, and accessory combinations such as hats and glasses. Each model can be randomised for diversity in background and mid-distance crowd shots.

Workflow and Pipeline Integration

iCrowds fits into Blender’s standard workflow:

1. Artists select a static distribution system.
2. Density and masking are refined via vertex groups or curves.
3. Static layouts are imported into dynamic systems such as Fluid or City for movement simulation.
4. Final adjustments include variation, physics tuning, and performance baking.

Systems can be mixed for specific production needs:
Urban environments benefit from combining City and Fluid systems; structured events can merge Walkers and Stadium; architectural projects may pair On Vertex with Fluid.

Use Cases Across Industries

The toolset is aimed at multidisciplinary users:

• Architecture & Visualisation: Quickly populate renders, simulate building capacity, and contextualise scenes with human scale.
• Game Development: Populate open worlds, generate background NPCs, and run behavioural simulations for day/night cycles.
• Film & Animation: Animate large background crowds and pre-visualise crowd movement in sequences.
• Urban Planning: Test pedestrian flow, space usage, and crowd density during design studies.

Price and Availability

iCrowds is available for $19 per licence on Superhive Market. The add-on supports Blender 4.5 and above on all major operating systems.

Stability Reminder

While iCrowds appears production-ready and technically mature, artists should verify performance and reliability in their own pipelines before integrating it into ongoing projects. Stability, agent count limits, and render compatibility may vary by system configuration.

The post City Life for Crowds: iCrowds Lands in Blender first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Beta Timeline and Scope

According to the official Blender 5.0 release notes, the version entered public beta in October 2025 and will remain in beta until 5 November 2025. Development continues under the branch blender-v5.0-release, which has entered bug-fix and performance-tuning mode. The final stable release is scheduled for 11 November 2025, following the standard two-week freeze window.

The beta covers virtually every subsystem in Blender, including Animation & Rigging, Assets, Colour Management, Compositor, Core, Cycles, EEVEE & Viewport, Geometry Nodes, Grease Pencil, Modelling & UV, Motion Tracking, Physics, Pipeline & I/O, Python API, Rendering, Sculpt/Paint/Texture, UI, Video Sequencer, and Virtual Reality.

Colour Management & HDR Workflow

Blender 5.0 Beta introduces native support for ACES 1.3 and ACES 2.0, offering modernised handling of scene-referred colour spaces. The upgrade aligns Blender’s colour management with industry standards for VFX and compositing pipelines. HDR display output now works under Wayland + Vulkan configurations on Linux, offering Rec.2100 PQ and HLG output paths. A new “Convert to Display” compositor node supports consistent mapping between working and display colour spaces. OpenEXR output also receives updates: multi-part files and embedded colour metadata are now supported, making interchange with Nuke, Fusion, and other parts in the pipeline more predictable.

Cycles, EEVEE & Rendering

Cycles gains several notable changes. Thin-film iridescence adds physical realism to materials such as soap bubbles or metallic coatings. The Random Walk SSS model now supports multi-bounce scattering, eliminating black seams at contact points.

A new volumetrics algorithm yields fewer artefacts and cleaner lighting for fog, smoke, and other dense simulations. The “Experimental” toggle in Render Settings has been removed, as formerly experimental options like Adaptive Subdivision are now production-ready. EEVEE also benefits from stability and performance improvements, while the viewport continues to consolidate Vulkan-based groundwork for future rendering backends.

Geometry Nodes and Pipeline Upgrades

The Geometry Nodes system continues its steady expansion. Blender 5.0 introduces Bundles and Closures, with similar data abstractions being integrated into Shader Nodes. Node workflows gain new structural features such as Repeat Zones and a Switch Menu node for conditional logic. Curve geometry drawing now supports a “Cylinder” mode, producing thicker 3D curves instead of flat ribbons—a small but visible upgrade for procedural modelling and motion-graphics work. Pipeline & I/O modules gain support for better data consistency, including expanded data-block naming and compression improvements.

Compositor, Assets & Interface Updates

The Compositor now includes access to the Asset Shelf, bringing it in line with other editors. This enables reuse of common node groups directly from the shelf. The User Interface gains numerous small refinements, improving discoverability and uniformity across editors. In Assets, the catalog system continues to stabilise, while Video Sequencer receives minor performance and interface updates for smoother timeline handling.

Compatibility and Deprecated Features

Blender 5.0 enforces stricter compatibility and hardware rules to modernise the codebase:

• Maximum Data-Block name length increased to 255 bytes.
• Runtime-defined property access (an unsupported feature) has been removed.
• Big endian platform support is dropped.
• LZMA and LZO-compressed point caches are no longer supported.
• Intel Mac support is removed; Apple Silicon is now required for macOS builds.
• Pre-2.50 animation data is no longer compatible.
• CUDA minimum compute capability raised to sm_50 (≈ GeForce 900 series).
• Blendfile compression is now enabled by default upon saving.

These changes may affect legacy add-ons, render farms, or archived project files. Studios should test migration paths carefully and update toolchains before adopting 5.0 in production.

In Beta: Test, Don’t Deploy

Verdict

As always, beta software is best treated as unstable. Some new features, particularly HDR display and Vulkan viewport modes, depend on specific hardware and driver setups. Artists and TDs should test features on cloned project files, not live productions. And after a recent feedback, that is highlighted. (Honestly, Mike, my dude, what were you thinking?!?!?!!?) The Blender Foundation encourages users to report regressions and UI inconsistencies via developer.blender.org.

Blender 5.0 Beta is a broad, technically ambitious release. Its expanded node systems, ACES 2.0 colour handling, and revised rendering core represent tangible steps toward a more production-grade platform. The compatibility break with older Macs and data formats, though inconvenient, clears the way for a leaner and faster codebase.

Studios should watch the November release closely but keep current projects on 4.2 or earlier until the stable 5.0 build proves itself in real-world conditions.

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

Chaos released V-Ray 7.1 for Blender (branded as Update 1) on 26 August 2025. It marks the first substantial update to the freshly launched V-Ray-in-Blender integration, adding two widely awaited features: direct support for Geometry Nodes and a one-click Cycles-to-V-Ray material conversion. The release also ensures compatibility with Blender 4.5 LTS and introduces support for the OpenPBR material standard.

Integration of Geometry Nodes

Geometry Nodes is Blender’s node-based procedural geometry system, used extensively for scattering, modeling, and automating complex setups. The initial V-Ray 7 release lacked support for it, forcing users to bake geometry prior to rendering. Now, V-Ray 7.1 renders Geometry Nodes setups natively—procedural elements no longer need workaround baking or scene conversion. This addition aligns the integration with Blender’s evolving procedural landscape.

Cycles-to-V-Ray Material Converter

Previously, materials authored for Blender’s built-in Cycles renderer had to be recreated manually in V-Ray’s system. Version 7.1 introduces a converter that automates this process. With one click, users can convert Cycles materials into V-Ray equivalents. The converter works globally via a V-Ray menu or can be applied node-by-node within the shader graph. For production pipelines with extensive Cycles setups, this saves significant manual labour.

Added Compatibility: Blender 4.5 LTS & OpenPBR

The update brings official support for Blender 4.5 LTS, Blender’s current long-term support release as of mid–July 2025, expected to remain maintained through July 2027 under Blender’s release schedule. OpenPBR is an open material specification developed by the Academy Software Foundation to standardise physically based material definitions across tools. V-Ray 7.1’s support for OpenPBR aims to smooth inter-application workflows and reduce material authoring friction.

Background: V-Ray 7 for Blender’s January Launch

V-Ray 7 for Blender (or the original native integration) launched on 1 July 2025. It replaced the legacy plugin (for Blender 2.79) with a fully embedded V-Ray engine inside Blender’s viewport. Core features included CPU, GPU and hybrid rendering, denoising, the V-Ray Frame Buffer (VFB), hair system support, proxies, .vrscene exchange, and initial Cycles material compatibility. Geometry Nodes and distributed rendering were not supported at launch.

V-Ray for Blender: Chaos releases Renderer into the Open Source Universe

Licensing, Platforms & Limitations

V-Ray 7.1 for Blender is available on Windows 10+ only, using NVIDIA GPU rendering. CPU-only mode and macOS or Linux support are still unavailable. Licensing is via rental-only subscriptions:

• Standalone V-Ray for Blender: $33/month or $199/year (named-user), includes Chaos Cosmos assets and Chaos Cloud rendering.
• V-Ray Solo: $84.90/month or $514.80/year.
• V-Ray Premium: $119.90/month or $718.80/year.

Existing subscribers for other V-Ray products already have access to the Blender integration.

Production Readiness & Testing

While Geometry Nodes support and Cycles material conversion are significant steps, users should validate both in actual production contexts. Complex node setups, linked assets, or custom shaders may still require manual adjustment. OpenPBR compliance may vary depending on the material library. Testing across render farms, GPU hardware, and versioned pipelines remains essential, for both performance and visual fidelity.

The post V‑Ray 7.1 for Blender: Geometry Nodes and Material Converter first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

“Red Poppies” (original title: “Czerwone Maki”) is a 2024 Polish war drama directed by Krzysztof Łukaszewicz. The film portrays the legendary Battle of Monte Cassino through the eyes of Jędrek, a young man who endures the harrowing experiences of a Soviet gulag and later joins the Polish II Corps.

The cinematography is crafted by Arkadiusz Tomiak, with Marek Warszewski serving as the art director and Agnieszka Sobiecka designing the costumes. The screenplay is also penned by director Krzysztof Łukaszewicz.

Produced by Wytwórnia Filmów Dokumentalnych i Fabularnych (WFDiF), “Red Poppies” is co-produced by ORKA, a company that expressed pride in contributing to the first Polish feature film about the Battle of Monte Cassino. The film’s visual effects were handled by Imaginary Pixels, a Polish VFX studio responsible for over 120 shots involving 3D tanks, set extensions, and the digital recreation of Wojtek the bear, a historical figure known for aiding Polish soldiers during World War II. https://kinoswiat.pl/film/czerwone-maki

The VFX team for “Red Poppies” included:​

Maciek Wojtkiewicz – Senior Animator
Lukas Remis – VFX Supervisor​
Artem Huza, Kajetan Czarnecki, Trendafil Kirilov, Jorge Grandes, Siarhei Talashka – Compositing Artists​
Severi Kamppi – 3D Lead​
Jyri Kataja – 3D Generalist​
Patryk Ptasiński – FX Artist​

DP: Let’s start with Red Poppies: How did you get involved with that production?
Lukas Remis: Red Poppies was a Polish production with one of the biggest budgets in recent years. It’s a war movie with over 400 VFX shots. Imaginary Pixels was one of 3 vendors, and we were brought in by the production company, that we have worked with in the past. For this project we’ve delivered over 120 shots, with a team of 12 artists, in about 4 months. Our work involved 3D set extensions, crowd and tanks multiplication, 3D creature creation and animation, and a lot of explosions and bullet hits.
The most complex part of the work was creating and animating a 3D version of Wojtek the bear. Wojtek was a Syrian brown bear adopted by Polish soldiers during World War II. There were about 15 shots with the creature, and many of them included interaction with the actors. Blender was our main and only tool for that. All aspects, from modelling, rigging, grooming, to animation and rendering were done in Blender. Our rig had some elements that were calculated automatically, like skin around the mouth or the ears. The goal was to have more physically accurate movement and faster workflow.

Another large part of our work were set extensions – usually mountains in the midground or background. For the background mountains, we have created a 360-degree environment in Blender, matching the terrain and foliage of Monte Casino in Italy, where the action should take place. We’ve rendered that as a 22K equirectangular image (Nuke wasn’t able to handle a larger render with AOVs) with some passes and different light direction versions. That way, the compositing team was able to use it as projections, for any angle in multiple shots, without involving the 3D artists each time.

DP: Can you break down your postproduction pipeline—from asset creation to final render—and specify which tools you used at each step?
Lukas Remis: Our pipeline is based on Ubuntu Linux. Projects are managed using Kitsu – an open source production management and review platform. We’re using Blender exclusively for all 3D tasks, and it’s native renderer – Cycles – for rendering. Render management is done with CGRU Afanasy. Compositing in Nuke. We’ve used Houdini in the past for FX, but currently we’re using mostly Embergen. Additionally we’re using Krita for photo or textures editing and MRV2 for playback and review. We’re also using Davinci Resolve for editing.

DP: Why did Imaginary Pixels as a full, working VFX shift toward open-source tools? Was this a gradual evolution or a clear strategic decision?
Lukas Remis: Personally, I have always been interested in the open source community and software, long before starting a career in VFX. I’ve been testing and playing with different Linux distributions in the past. Since a couple of years Linux, and Ubuntu as my personal favourite, has surpassed Windows functionality and stability, so it was a natural choice for an OS for all our machines. As for the other tools, like Blender, Kitsu or MRV2, the financial aspect is of course very important, but we only adopt an open source solution if it’s really capable of delivering what we need, efficiently. Blender was there from the beginning, the other tools came gradually, while we were looking for solutions to different areas.

Kitsu, the project management platform, is definitely worth mentioning here. It’s a wonderful software, with great people behind it. It was used, together with Blender, for this year’s Oscar winner: Flow.

DP: Are there areas in your pipeline where proprietary tools remain essential? What can’t be replaced by open-source alternatives—yet?
Lukas Remis: Obviously, in compositing we are stuck with proprietary software – and Nuke as the industry standard. And even the alternatives are not open source. Recently, I’ve been reaching out to several VFX studios to build a Natron development group, because I believe this software could take over a large part of Nuke compositing if the development would be revived. Natron’s similarity to Nuke makes it a great candidate for a compositing software alternative. Almost all the studios that I talked to expressed an interest in this initiative, and I have also talked to a “large” open source organization that would be interested in taking over Natron development – if appropriate funding is provided of course. I think a “Blender-like” development fund, with some VFX companies behind it, could provide the necessary funds for this.

FX software is another proprietary area. Houdini is fantastic software, but for a small studio like us, it’s expensive, especially that simulations are not our daily tasks. That’s why we’ve started working with Embergen. It’s still not close to the level of Houdini, but it successfully manages many of our tasks. And with the announced updates it will be even more useful.

DP: How do you manage bugs or tool limitations during production? Do you patch internally, rely on community support, or contract developers?
Lukas Remis: We don’t have inhouse developers, so we must rely on the development team behind each software. This can be difficult – for example I’ve reported a Blender bug over 7 years ago – it was about Blender not importing focal length animation of cameras in Alembic format – and it’s still not fixed! I can imagine this is a relatively simple fix, but the bug is a pretty big problem. On Red Poppies we also had some issues with the bear’s fur and alembic caches, but we just found some workarounds. But bugs are a thing, no matter if it’s open source or proprietary software. I have reached out to Nuke’s support several times without getting a solution to a problem. For example with the license server not working properly and they were unable to provide a solution. I can understand a bug in a free software, but certainly not in a crazy-expensive software like Nuke.

On the other hand, I had an amazing experience with the developers behind Kitsu and MRV2. They are very responsive and fast. I was especially blown away with Gonzalo Garramuño, the creator of MRV2. A couple of times he reacted within minutes from posting a bug, and provided a fixed version of the software. I think the open source developers and community are in general more approachable.

DP: What’s your perspective on open file formats like USD, OpenEXR, Alembic, or OpenTimelineIO?  Do they streamline your pipeline, or cause compatibility challenges?
Lukas Remis: Those are a “must”. OpenEXR and Alembic are standard daily-used formats, even to exchange data between different software internally. As for USD, we’ve used it on several occasions, where we needed to exchange 3D scenes with other studios – for example on “Return to Silent Hill”, for which we’ve been mostly building environments, using Blender.

DP: How much custom development went into making your pipeline as a whole work? Are you using off-the-shelf pipeline tools or building your own solutions?
Lukas Remis: Kitsu is great as a management and review platform, but it lacks software integration. So I’ve developed a program, which connects with Kitsu database, using it’s API, and at the same time it manages all our project and media files. It allows us to load specific project versions to DCC software, and submit output for review directly to Kitsu. This was created with Python. I know several programming languages, but I’ve never done anything in Python, so I wrote the software with chatGPT.

Also I’ve decided to have Kitsu installed on our own internal server, which makes it free. But you can also choose Kitsu’s hosting and management, with some monthly fee, if you want to avoid any technical work.

DP: Open source reduces licensing costs – and no licence server means an easy cloud deployment – are you using tools on Cloud or Hybrid infrastructure?
Lukas Remis: At the moment, considering we’re a small studio, I feel more comfortable with on-premise hardware. Especially that it’s hard to calculate the actual costs of cloud solutions – it’s more like estimations. I prefer to invest in our workstations or local render farm, because it’s going to be here and waiting for another project even during a down time. And our workstations are prepared for freelancers to work remotely. But I’ve talked with Mihai Satmarean from skylitetek.com about the possibilities of implementing their cloud solutions, and this will definitely be a thing if we grow bigger or need a quick ramp up. Skylitetek expertise is really valuable because they have experience working with VFX studios and their pipelines, not just delivering some generic cloud solutions.
In the meantime their team has helped us with some network and user management configuration. We don’t have any of the DCC software installed directly on the workstations. We’re using a “central” NAS which is hosting it for all our users. This was a thing I’ve implemented a long time ago, but now we needed to make it more advanced and add an LDAP user management.

DP: How reliant are you on cloud infrastructure? Are you using it for rendering, collaboration, asset management—or all of the above?
Lukas Remis: I’ve used some cloud/online rendering solutions in the past, but currently we’re fully relying on our hardware. Remote artists can connect with our VPN and “stream” a workstation, and they have access to all project data.

DP: How do you find and train artists comfortable with open-source tools like Blender or Gaffer? Is the talent pool growing—or do you invest heavily in onboarding?
Lukas Remis: At the moment Blender is our only open-source app that requires artists to know it. We have amazing Blender generalists, and the software is so popular that it’s not that hard to find new talent. For Red Poppies we needed a senior animator for some of the bear shots, and I’ve reached out to a friend of mine, who’s a Maya animator. He was willing to try animating in Blender, and all he needed was some Youtube tutorial about Blender basics, and introduction to our pipeline. After getting familiar with the interface he said he doesn’t see much difference for the animation process.

DP: Is Imaginary Pixels contributing to the open-source projects you use—via code, bug fixes, or documentation?
Lukas Remis:  As mentioned we don’t have developers in our team, so we can only report bugs. But of course we are financially supporting Blender, Krita or Kitsu. Kitsu also has a nice system for recommending new features, so we can suggest changes based on real-world cases.

DP: Are you planning to expand your open-source pipeline for future projects? Any new workflows—real-time rendering, AI, virtual production—on the horizon?
Lukas Remis:  Of course like everyone we’re thinking about AI and it’s possible applications. However, so far, most of the generative tools that I’ve tested are nowhere near being production ready. The main issue is complete randomness and lack of output control. But the media are completely hyped with AI, presenting it as the downfall of VFX and Hollywood in general :)

We’re using some AI tools integrated with Nuke, and planning to implement some generative AI with ComfyUI.

DP: What are your criteria when evaluating a new open-source tool for adoption? How do you assess codebase health, community size, or long-term viability?
Lukas Remis: The easiest way is to check the software’s GitHub page, and see how many people are contributing to the code and how often. That’s something you never know when using commercial closed-source software.

DP: Open-source projects can be abandoned. How do you hedge against that risk?
Lukas Remis: Yes, there’s always a risk that an open-source project can be abandoned. However, as we have recently seen with Foundry’s Modo, you’re not getting any guarantees with commercial software as well. Modo’s users have not only been abandoned, but also their licences are going to be cancelled. So they won’t be able to even use the old versions. With open-source, the code is still there, even if it’s abandoned. And you can continue developing it by yourself.

DP: How has the shift to open-source tools changed your studio culture—especially in terms of collaboration, experimentation, and problem-solving?
Lukas Remis:  I think using open source software encourages everyone to experiment. There is no “correct way” of doing things, you should always search for new possibilities and stay creative. Our artists often send me links to some new, interesting tools they found, so we can consider if that would be useful for us.

DP: Would you say your current pipeline is fully production-ready—or still evolving? What advice would you give to other studios considering a similar move?
Lukas Remis:  Yes, it is production ready. We’re using it on all our projects. Of course, it’s still evolving, as things that work for us now, might not work when we grow bigger or when we meet different tasks. But the beauty of open-source software is that you can try it for free. If it turns out that a tool is not meeting your requirements, you can just move on, or perhaps help to develop the tool. With commercial software, usually when you invest large amounts of money in some solutions, it might not be possible to just move to something else. Obviously, it’s not possible to be completely open-source when you want to make professional VFX, but there’s a lot of great free software out there.

DP: What good resources are out there to learn more about it?
Lukas Remis:  For Blender, your best source of information will be YouTube and Stack Exchange. And for general information about open source VFX tools, I recommend this page:github.com/cgwire/awesome-cg-vfx-pipeline – it’s an extensive list of different projects, covering any aspect of a VFX pipeline.

DP: What is the next project you are working on (insofar as you can talk about it)?
Lukas Remis:  At the moment we’re working on some Polish projects: a TV series and a feature film: Vinci 2. At the beginning of this year, we worked on several commercials for the Super Bowl, and before that we were focused on Return to Silent Hill, which should have a premiere at the end of this year.

The post Red Poppies, Bears and Open Source! first appeared on DIGITAL PRODUCTION and was written by Bela Beier.