For those who don’t know the tool: Mocha Pro from Boris FX handles planar tracking, PowerMesh, masking and roto as a standalone app or plugin for major editing and compositing hosts, like Resolve, After Effects, Premiere Pro, Avid Media Composer, Nuke, Fusion, Flame and Vegas Pro.

Points meet planes

Mocha Pro 2026.5 adds Point Track ML to PowerMesh and AdjustTrack. The new tracking mode analyses motion across a sequence rather than the frame-to-frame approach used by conventional point and planar trackers.

That’s relevant when a surface stops behaving. Cloth creases (Fashion!). Skin bends (Old Age!), Hands pass over faces (Facepalms!). Shadows move independently from the material beneath them (Are there Ghosts in here?). These are familiar ways to turn an apparently simple tracking task into an afternoon of vertex correction.

PowerMesh already handles local deformation across surfaces such as fabric and skin. Its sensitivity to fine movement also makes it vulnerable to occlusion, changing illumination and objects disappearing. Point Track ML supplies another tracking method for those cases.

The model assigns machine-learning point tracking to groups of mesh vertices and considers frames before and after the current position. Processing can advance in chunks rather than at a constant frame-by-frame rhythm because the tracker analyses a wider temporal range.

Mocha still exposes the resulting mesh for editing. Artists can adjust vertices, smooth curves and remove keyframes when the automated result needs help. Boris FX presents Point Track ML as another tracking option, not a universal replacement for planar tracking.

A clean, planar surface with a stable texture may still require nothing more exotic than the existing planar tracker. Machine learning earns its render time when the shot contains the sort of organic interference that usually produces organic corrections (e.a.: Artist needs to get involved)

Mocha Occlusion without the ritual

A traditional PowerMesh setup may require a separate roto layer for an object moving in front of the tracked surface. That layer protects the tracker from the occluder, but vertices beneath it can lose the subtle deformation that the artist wanted to capture.

Point Track ML targets that gap. It follows the wider motion of the sequence and attempts to preserve movement beneath temporary obstructions. The backpack example in the Video above (Timestamp 6:11) exposes another limitation of planar methods. As the visible surface turns away, the planar shape can stretch into the background. Mesh vertices may also lose their reference when sections leave the image. Point Track ML can predict positions beyond the visible frame and recover them when the surface returns.

Refine Mode raises the analysis resolution for difficult material. It also increases processing time. This is a practical trade rather than a free accuracy switch, which makes it better suited to selected shots than automatic use across an entire sequence.

Artists can, of course, edit the generated mesh with the existing mesh tools. A large falloff area can reposition groups of vertices while retaining the surrounding deformation. Individual PowerMesh vertices also appear in the dope sheet and Curve Editor for direct keyframe work.

A new Planar from Mesh option converts the tracked mesh movement back into planar data. This gives artists a route through shots where a planar solve struggles, but a grid of Point Track ML points remains stable. The mesh performs the difficult tracking, then the resulting motion becomes planar data that can be adjusted or exported through familiar workflows.

AdjustTrack gets an Mocha assistant

AdjustTrack sits at the end of the tracking process. It adds corrective animation to existing tracking data when a surface drifts due to motion blur, fast movement, changing references, or regions leaving the frame. It remains a correction tool. An initial poor track will still produce a poor foundation. Changing the tracking shape or motion settings may solve a problem more cleanly before AdjustTrack enters the job.

When the underlying track works for most of a shot, Point Track ML can now drive “Auto Nudge”. Artists place reference points on recognisable features, choose the correction interval and let the system analyse forwards and backwards from the reference frame.

Support grids add tracking points around an individual reference, across the tracked surface or through a wider portion of the image. These helpers provide the tracker with additional context when the primary feature blurs, changes appearance, or moves off-screen.

The generated adjustments remain editable – Refine Mode exposes higher-resolution analysis when the standard pass lacks detail. This changes the amount of repetitive work not the logic of AdjustTrack. The module still layers corrections over existing data. It can now detect and compensate for drifting reference points without requiring an artist to reposition every one by hand.

A skateboard demonstration uses four bolts as correction references. Auto Nudge adds adjustments at defined frame intervals and keeps the insertion surface aligned despite visible drift in the original spline. The result can return to a host application or leave through the standard tracking-data export.

For compositing work, that means fewer manual surface corrections before a logo, patch or cleanup element can move with the plate. It does not remove the need to inspect the track. It reduces teh amount of keyframing required when the failure follows a predictable drift.

Smaller subjects, sharper boundaries

The masking update concentrates on regions of interest. Object Brush, Matte Assist ML and Refine Matte ML each gain controls that reduce how much of the image the model must consider. Machine-learning models operate within input-resolution limits. A large plate may need to be reduced before analysis, which can discard useful detail around a small subject. Processing a tighter region allows the model to allocate more of its available resolution to the object that matters.

Object Brush now previews the likely selection while the pointer moves across the image. The preview resolution adapts to machine performance. Clicking creates an automatic region of interest around the selected area.

Auto ROI narrows the image section passed to Mask ML. This can produce tighter boundaries around legs, clothing, hands and internal gaps. Artists can disable the automatic box and draw their own region by holding the Command or Control key while dragging around the target.

The feature concentrates model attention. It does not guarantee a final matte. Difficult edges may still require spline editing or subsequent refinement, particularly when the subject contains features that resemble the background. Matte Assist ML receives Search Area controls for propagation across a sequence. Instead of looking through a reduced version of the complete image for the object in the next frame, the tool can search within a defined area around the current matte.

The fields can be keyframed. Artists can widen the search when motion increases and tighten it when the subject remains relatively still. A smaller search area retains more local image detail and can improve contours around small figures, gaps between limbs and holes inside a silhouette. The control belongs in the Classic workspace with the more advanced matte settings.

Refine without background glitter

Refine Matte ML adds Auto ROI around the existing object boundary. The region limits how far outside the matte the model looks for soft edges. This helps remove isolated background sparkles and stray fragments that do not connect to the subject. Hair, motion-softened outlines and semi-transparent boundaries can retain finer detail without inviting unrelated texture from the rest of the frame. The ROI remains adjustable.

This is a sensible control for rotoscoping. Automatic cleanup often fails in two opposite directions: a broad search collects junk, while an aggressive crop removes legitimate edge detail. An editable region gives the artist some say in that negotiation.

The masking workflow still follows three stages. Object Brush creates the initial shape. Matte Assist ML propagates it through the shot. Refine Matte ML produces softer, more detailed edges from the binary result.

Curves for every vertex

The Curve Editor now displays PowerMesh vertex positions. Artists can inspect and modify keyframes for individual vertices instead of treating the mesh as one opaque result.

That is VERY useful, after an otherwise successful machine-learning pass. A track can remain stable across most of a sequence and still contain a small bump, ploink, blurb, bork, pause or offset. Direct vertex curves let the artist smooth or delete problematic animation without rebuilding the mesh.

The editor already visualises track parameters and supports curve smoothing. Mocha Pro 2026.5 extends that inspection to mesh-based motion. The dope sheet also exposes vertex keyframes. Together, both editors keep Point Track ML within a conventional animation workflow. The model generates data, but the operator retains access to the data that affects the image.

Mattes leave in better shapes

Mocha Pro 2026.5 expands rendered-shape and matte-data exports for studio pipelines. Rendered shapes can leave as RGBA with the source clip or another rendered clip. Earlier output concentrated on straight RGB matte data. Combining image and alpha can reduce extra assembly when downstream software expects a conventional RGBA element.

OpenEXR output stores separate layer mattes in a multilayer file. Each matte can occupy its own channel rather than being merged into a single result. This suits pipelines that want one container with independently addressable masks.

Transparent Matte Colors export separates layers through colour channels. Layer controls can assign selected mattes to pure red, green or blue, producing a transparent RGB overlay that downstream compositors can split into individual masks.

Matte-data export also gains an option to disable layer-opacity keyframes for After Effects, Fusion, and Flame. This prevents unwanted opacity animation from travelling with matte data when a receiving setup does not need it, or doesn’t know what to do with it and therefore crashes.

Export additions concentrate on rendered RGBA, multilayer OpenEXR, colour-separated transparent mattes and host-specific matte data. Point Track ML data can also return to planar motion before export. Matte generation consumes enough time already. Repacking channels after export is the sort of pipeline tax that nobody includes in the bid and everybody eventually pays.

Under the hood

Boris FX also adds native Windows on Arm support to the standalone application and the Adobe plugin, among a very few toolmakers. Other host plugins are not included in this Windows ARM update, but we’ll see what happens.

Prices and licences

Subscription pricing starts at 42 Euros per month or 290 Euros per year. Mocha Pro also remains available through perpetual licences (675€), upgrade and support plans. Customers with an active Mocha Pro subscription, Boris FX Suite subscription, Vegas Pro Ultimate subscription or a current Mocha Pro upgrade and support plan receive version 2026.5 as a complimentary update. A free trial runs for 14 days after installation and registration through the Boris FX Hub.

AI with handles attached

The most production-friendly part of Mocha 2026.5 is its refusal to hide the result behind a single button. Point Track ML generates an editable mesh. PowerMesh data can become planar data. AdjustTrack corrections remain adjustable per point. Search areas can be resized and animated.

The automation helps with repetitive repair without removing operator control. That suits shots where a tracker works for 90 per cent of the sequence and then loses its dignity behind an arm, a shadow or a motion-blurred skateboard. But still, new tools and innovations should always be tested on representative footage before use in production.

Get the free trial here: https://borisfx.com/free-trial/?product=mochapro

See what else is new: https://borisfx.com/products/mocha-pro/#whats-new

The post Mocha Pro 2026.5 Tracks Through Trouble first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: DroneSiteBuilder is a script for Autodesk 3ds Max (AND BELDNER )that reads drone photo metadata to assemble terrain, map context, and matched cameras, bundling GeoBuild and CameraMatch and supporting handoff to Blender, SketchUp, and Autodesk Maya.

UPDATE

This just in, and we are quoting the Developer: DroneSiteBuilder is now available for Blender users too. The Blender edition I mentioned was “coming soon” is here, so the full drone-photo-to-3D-site workflow now runs natively in Blender as well as 3ds Max.

What DroneSiteBuilder is trying to fix

DroneSiteBuilder Enterprise turns a folder of drone photos into a full site context scene inside the 3ds Max ecosystem: terrain, aerial drape, buildings, roads, land cover features, points of interest, and one matched camera per photo.

The pipeline reads XMP metadata per image and uses it to place helpers at ground level and flight altitude, then creates a renderer-aware camera per photo and refines orientation using vanishing point detection. The tool targets 3ds Max 2020 or newer on Windows and uses Python 3.9 through 3.12 with NumPy and OpenCV, plus optional modules for the Google path.

First use, abbreviated

Install a standalone Python build and make sure Add Python to PATH is enabled during install, because the tool does not rely on the 3ds Max built-in Python. Place DroneSiteBuilder_Enterprise.ms and vp_detector.py in the same folder and do not install under Program Files, since Windows blocks writes there.

Launch 3ds Max and load the script via drag-and-drop into a viewport or via Scripting > Run Script. Paste your licence key into the activation dialogue and activate, with support for an Enterprise key format and existing CameraMatch Studio keys. After activation the key caches locally for thirty days and the rollout opens.

For the first build, keep original DNG or JPEG drone files in a single folder, keep filenames ending in digits, and keep an internet connection available for the auto fetch steps. Pick a terrain DEM source, keep NOAA GEOID18 enabled for continental US sites and disabled outside the US, then run Process Folder of Drone Photos and accept the summary dialogue. Inspect the result by comparing a matched camera view against the source photo.

The new checkbox: Google Photorealistic 3D Tiles

Enterprise v1.2 adds an opt in mode that fetches Google Photorealistic 3D Tiles and imports them into 3ds Max as a single merged glb, covering the photo bounding box. The intention is simple: pull a photogrammetric backdrop mesh with terrain, textures, and buildings baked into one continuous model, using the same dataset shown in Google Earth.

The Google path requires a Google Maps Platform project with billing enabled and the Map Tiles API enabled, plus a saved API key in the rollout. The manual describes 1,000 root tileset requests per month free and a per 1,000 price after that, with one DroneSiteBuilder run treated as one root tileset request. If the fetch fails, the tool reports common causes like missing API enablement, low coverage, EEA billed accounts being blocked for this endpoint, missing Python modules, and older 3ds Max builds needing a glTF importer.

This is also where the gaudrrails get real: the Google import produces mesh only content with baked textures, so you do not get separate terrain, buildings, roads, and features objects to isolate, re material, or hide by category.

The standard path is still the controllable one

If you leave the Google option off, the pipeline builds a layered context using public services. Terrain comes from USGS 3DEP in the US or OpenTopography worldwide, aerial imagery comes from Esri World Imagery as a single bounding box JPEG, and vector context comes from OpenStreetMap via Overpass.

The scene builds under a single root helper so you can move, rotate, or scale the entire site as one unit, while cameras intentionally sit outside that parent chain to support camera transplant between scenes. If buildings and roads fail to appear on a run, the manual provides a manual Overpass refetch button that rebuilds buildings, roads, and land features without disturbing terrain, drape, helpers, or cameras.

OpenStreetMap accuracy varies by location and that the resulting geometry accuracy for this context layer sits in the one to six meter range. It contrasts that with paid city model providers such as AccuCities when millimeter level detail matters.

Export and handoff from 3ds Max

DroneSiteBuilder does not change how 3ds Max exports, but it does influence what you export. The standard path creates distinct terrain, buildings, roads, and feature objects you can selectively include in deliverables, while the Google path imports a tile based mesh group that is already baked.

For broad DCC and engine handoffs, 3ds Max includes a built in exporter for glTF and supports export workflows for USD, with export options available through File export and USD and USDZ format selection when the USD tooling is installed. For USD pipelines, the official OpenUSD plugin for 3ds Max is published on GitHub, and Autodesk documentation describes supported USD content types including meshes and cameras.

If your downstream is realtime, glTF targets web and interactive use cases, and you can also push common interchange paths like FBX into engines such as Unity and Epic Unreal Engine, depending on your studio conventions. For camera and layout continuity between scenes, the bundle includes a camera transplant workflow that exports camera data to JSON and recreates it with full precision in another scene.

Practical reality check

This toolkit aims to comperss a traditional drone to 3D context workflow into a short unattended run. The promise stands or falls on your input photos keeping XMP metadata intact, on your site area having decent public map coverage, and on you verifying the result against the plate before trusting it.

We don’t know the price yet, but if you already own the camera match tool in the Studio version, you get it for free, apparently. Quoting: Existing CameraMatch Studio licence keys activate the full DroneSiteBuilder bundle. Studio holders do not pay twice. 

Try both context modes on a test job: the standard layered build when you need controllable components and re-lighting freedom, the Google mesh mode when you need a fast photogrammetry backdrop and can live with mesh-only content and licensing constraints.

https://jamiecardoso-mentalray.blogspot.com/2026/03/dronesitebuilder-enterprise-v12-one.html

https://jamiecardoso.gumroad.com/

The post DroneSiteBuilder adds Google 3D Tiles option first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: 3DGS Render brings Gaussian splat import, editing, conversion and rendering into Blender. It works with PLY data and complements the KIRI Engine scanning app.

Splats learn to move

KIRI Innovation has released 3DGS Render 5.0, a free and open-source Blender add-on for handling 3D Gaussian Splatting data. The major addition transfers deformation from a proxy mesh to a Gaussian splat object. Artists can rig and animate a conventional mesh, then use that mesh to drive the splats. This brings familiar armature and character-animation methods into a data type better known for capturing static objects and environments.

The workflow does not turn the splat into a conventional polygon model. The mesh acts as the deformation source. The add-on transfers its changing shape to the Gaussian data, which can then be baked over time.

Rigging and animation tools stay on the mesh side, where Blender artists already know how to work. The splats receive the resulting deformation instead of demanding an entirely separate animation system. A demonstration transfers a stock Mixamo animation to a scanned character. The proxy carries the animation, while the splat representation follows its deformation.

The animation feature remains VERY experimental. Performance is currently limited, even though the workflow functions. That makes version 5.0 useful for tests, research and less time-sensitive work, rather than an automatic invitation to place tomorrow morning’s delivery on its shoulders.

Proxy business

The new deformation transfer begins with a proxy mesh that corresponds to the splat object. A rigged character can fill that role. Artists animate the mesh through standard Blender tools, including an armature. The add-on then transfers the deformations to the Gaussian splats. This separates animation control from the captured representation and avoids asking artists to rig a cloud of anisotropic primitives directly.

https://www.youtube.com/@3D-Tools-by-KIRI-Engine

The approach also permits existing character animation to enter the workflow. A suitable proxy can receive motion first, after which 3DGS Render passes the deformation to the splat object. That does not erase the preparation step. The mesh still needs to function as a usable proxy for the captured subject. Version 5.0 provides the transfer mechanism rather than replacing rigging, skinning or animation work.

Once transferred, the animation can be baked as a sequence of PLY files. Software that supports animated splat data through frame sequences can then receive the result outside Blender. But beware: Blender will burn during that, and you WILL take a long break.

The export method is refreshingly literal. Each frame becomes splat data rather than a compact rig with reusable controls. This gives the receiving application the baked result, while the editable rig and proxy workflow remain inside Blender.

Anyone expecting a universal character interchange format should read the filename twice. This is a sequence of PLY files, with the practical storage and pipeline implications that such a sequence brings. Meaning: Your storage will be F….illed.

Light joins the ride

Version 5.0 can also bake lighting information from the proxy mesh to the 3DGS object. That gives the proxy another job beyond deformation. Its surface can carry lighting information that transfers to the splats, joining the animation bake. Earlier versions already let imported splats react to lighting and cast shadows through the add-on’s real-time rendering mode. The new bake path connects proxy-based lighting with exported splat animation.

Inside Blender, 3DGS Render can relight splats and render them with Eevee. Artists can therefore keep capture data, proxy geometry, animation and lighting in one DCC while preparing the result. The release does not claim that baked proxy lighting replaces every lighting workflow. It provides a route for transferring that information to the splat object and carrying the result into the baked sequence.

The existing toolbox stays

Animation arrives on top of the add-on’s established editing and conversion tools. 3DGS Render imports 3DGS data stored in PLY files. Imported splats behave as Blender objects for common transformations, allowing artists to move and rescale them within a scene. The tool can crop unwanted areas from raw scans and merge separate scans. Those operations address the untidy reality of capture data, where the desired subject often arrives with pieces of floor, background or neighbouring geometry attached.

Colour editing and modifiers remain part of the workflow. The repository also describes point-cloud editing and optimisation before conversion into 3DGS data. The add-on can convert conventional meshes into 3DGS PLY files. That opens the opposite direction of travel: a mesh can become splat data for export into other software that supports the format.

Splat happens: Volinga 3DGS workflow for Unreal

The 3DGS format sits at the centre of all these operations. For a closer explanation of splats and their place in realtime production, Digital Production’s Volinga 3DGS workflow for Unreal covers the underlying representation and its practical use in an engine pipeline.

The new functionality does not promise interactive playback at production speed. Its experimental status and current performance limits should remain visible during scheduling, especially with dense scans or long frame ranges.

A short test sequence should reveal more than a triumphant press-release adjective ever could. New tools and innovations should always be tested before use in production.

Free, open and experimental

3DGS Render 5.0 costs nothing to download. Its source code is available under the Apache License 2.0. Free access does not remove the cost of validation. Teams still need to test installation, dependency compatibility, animation transfer, lighting bake, export size and playback in the destination tool.

The experimental animation feature makes that validation particularly important. It works, but current performance remains limited. The honest reading is more useful than a glossy one: splats can now follow a rigged proxy, though they have not promised to sprint.

For artists exploring animated capture data inside Blender, version 5.0 supplies a concrete workflow. Build or obtain a suitable proxy, animate it with familiar tools, transfer deformation and lighting, then bake the Gaussian result into PLY frames.

https://www.kiriengine.app/3d-tools

https://github.com/Kiri-Innovation/3dgs-render-blender-addon

The post Let’s Animate Splats in 3DGS Render? first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Some assembly required

Epic Games has placed Modular SciFi Station in Fab’s current limited-time free collection. The promotion ends on 16 June 2026 at 9:59 AM Eastern Time.

Environment artist Martin Milz created the package. It contains the structures and surfaces needed to assemble a realistic science-fiction station inside Unreal Engine as a collection of assets, maps and materials created for realistic AAA visual targets and production budgets.

The pack uses a modular construction approach. Artists can combine reusable sections rather than treating the station as one fixed environment – all the Greeblies, so to speak. Walls, floors and specialised science-fiction components can form different layouts from the same source pieces. That puts the package squarely in environment art territory. It can supply a starting point for game levels, realtime backgrounds, motion graphics shots and visual effects environments without requiring every corridor panel to begin life as an empty polygon.

147 pieces of future furniture

The pack contains 147 unique 3D meshes. Its architectural parts include metal walls and flooring. The more specialised pieces include solar panels, antennae and circuitry. Together, these elements cover both the structural shell and the smaller details that make a base look occupied by someone with an alarming electricity bill. Vertex counts range from 500 to 10,000 vertices per part. The assets also include levels of detail, and those LODs give Unreal projects multiple mesh representations for different viewing distances.

The pack targets realistic imagery rather than a stylised visual language. Its product description calls the assets AAA quality. That wording is a marketing claim. The listing does not provide a production benchmark or performance target that defines the term.

Still, 147 modular pieces provide considerably more variation than a single finished station model. Artists can arrange teh same components into multiple rooms, corridors and exterior structures while retaining a common design language.

Materials included

The collection contains four master materials and 44 material instances. The surfaces cover metal, fabric and ground materials. Texture resolution reaches 4,096 by 4,096 pixels. Master materials let a project control shared shader behaviour from a smaller number of parent setups. Material instances then expose variations without requiring a separate shader network for every wall panel or floor tile.

Engine range

The package supports Unreal Engine 4.20 and later releases in the Unreal Engine 4 line. The listing is marked as not generated with AI. It also marks AI usage as not allowed.

Licence without the fog machine

The assets use the Fab Standard License. That licence permits private and commercial use. Artists may modify the assets and incorporate them into projects. Completed projects may be distributed commercially with the content inside them. The licence also permits use with compatible tools beyond Unreal Engine. It does not restrict licensed content to Epic’s engine.

Collaborators working on the same project may receive the asset directly, through a private repository or as part of the project. That permission does not turn the package into a general studio free-for-all. Sharing applies to collaborators working on the licensed project

Free has an expiry date

Modular SciFi Station is free through 16 June 2026 at 9:59 AM Eastern Time.

Modular SciFi Station on Fab

Fab Limited-Time Free collection

Fab Standard License

The post Free Sci-Fi Station Lands on Fab first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: Cinema 4D is Maxon’s 3D application for modelling, animation, simulation and motion graphics. Version 2026.3 updates UV work, MoGraph cloning and simulation particle management.

UV editing starts over

Cinema 4D 2026.3 introduces a completely new UV editor. It uses the same viewport technology as the main 3D viewport instead of the older system built around BodyPaint dependencies. The workflow remains familiar. Projection, unwrapping, relaxing and packing still occupy recognisable parts of the layout. Automatic packing remains available as a one-click route for assets headed to 3D painting tools such as Substance 3D.

Manual workflows gain ABF unwrapping, local relaxation, pinning, revised packing controls and access to standard modelling tools. The geometric packing method remains available for arranging islands inside the active tile.

Seams become explicit

Version 2026.3 replaces proximity-based UV separation with explicit seams. A seam behaves as a specialised edge selection tag. Artists can mark geometry, clear the active component selection and continue working without losing the UV boundary. This reduces accidental welding when neighbouring UV points sit close together. It also keeps modelling selections and UV boundaries separate.

The editor includes a dedicated seam selection tool. Artists can draw seams directly, extend them through loops and paths, or generate them from polygon selections. Marking selected polygons creates a seam around their open boundary.

Fewer ceremonial clicks

Several smaller changes target operations repeated throughout a working day. Loop selection can stop at existing selections while allowing an enclosed loop to be subtracted. Clicking outside the geometry clears a component selection without switching back to the Move tool. Island alignment also becomes more direct. Hovering over an island edge previews the target, while clicking aligns the island to that edge.

The coordinate manager now works in UV space with absolute values. Artists can position islands precisely and define how much of a tile their bounding boxes occupy. The current build displays these percentages at ten times their actual values. A shown value of 400 corresponds to 40 percent. The bug is planned for correction.

Welding gains directions

The revised weld tool previews which island will move. Direction arrows appear while hovering over compatible edges. Artists can move one complete island onto another or use a modifier to make both sides meet at the midpoint. This provides better control over which parts of an existing layout remain stationary.

The editor also includes a standard transform gizmo with working rotation axes. The previous UV gizmo has been removed. A possible replacement remains under design. Selected UV edges can be straightened and pinned before another unwrap. Mirror commands can place sufficiently similar islands together for symmetrical texture work.

Pins can take a break

UV pins can now be suspended without deleting them. Artists may release the pins temporarily, adjust an island and then reactivate the same constraints. A brush tool provides smear, smooth and relax modes with adjustable size and strength. These operations work locally and respect active pins. Selection synchronisation between the 3D and UV viewports can be enabled or disabled. Context menus adapt to point, edge or polygon mode. The workflow still expects artists to understand why they are cutting an asset. It simply removes several clicks previously required to prove it.

UDIMs remain active

The editor supports UDIM workflows. Opening a texture with a recognised UDIM token can load either the selected image or the detected tile sequence. Moving an island outside the default tile activates the destination tile. Artists do not need a separate Create UDIM command. Unsupported tile numbers appear in red. The default tile may also display in red despite remaining valid. Multiple UV tags can exist on one object.

BodyPaint stays

The rebuilt editor does not remove BodyPaint 3D. Artists can still paint in 2D or 3D and work with layered bitmap textures. Direct support for Redshift materials remains limited in this workflow. Artists can save the painted bitmap and load it into a Redshift material afterward. The new editor therefore separates modern UV handling form the older painting system without deleting the latter.

Particle properties get a map

Simulation particles receive a Particle Property Manager. It lists particle properties and identifies where each one originates, where it is read and where it is modified. Custom properties appear as artists add them. Selecting an entry can locate the scene entity using it, which should help when debugging larger particle setups.

MoGraph learns the edges

MoGraph gains three Advanced Distribution types: Edge, Rivet and UV Projection. The Edge distribution clones objects along mesh edges. It supports multiple source objects, random or iterative clone assignment, count controls, gaps, pinching, initial rotation and random seeds.

Scale can change toward an edge’s centre or its endpoints. Spacing remains aware of clone dimensions as scale changes.

Surface Offset moves clones relative to the mesh. Scaling can remain uniform or follow the edge direction. Colour can stay constant, follow a linear gradient or vary randomly.

An Animation Speed parameter animates the distribution without requiring a separate effector.

Rivets without the rigging ritual

The Rivet distribution places clones around polygon boundaries. Typical targets include screws, bolts and repeated fasteners. It generates separate corner and interconnect clones. Artists can control their count, spacing, scale, spin and jitter independently. Polygon selections restrict the effect to chosen areas. This allows a procedural modelling stack to preserve selected front faces while excluding bevel polygons.

The distribution also works with ngons when supplied with the relevant selection. Curved ngons may produce less predictable placement because they do not lie on one plane. Standard effectors can animate rivets. A Plane Effector and Field can offset, rotate and scale screws as they arrive. The same distribution can also drive boolean cutters for matching recessed holes. It is a narrow tool. Narrow tools are excellent when they replace an afternoon of rigging.

Clones surf across UV space

UV Projection places and animates clones through an object’s UV coordinates. It evaluates a clone’s position in the 2D layout and projects that position back onto the 3D surface. Regular UV layouts provide the cleanest starting point. A plane maps directly to a grid, while a torus carries the same movement around its curved surface.

The distribution includes deterministic and dependent animation modes. Deterministic mode reproduces the same result for a given frame. Dependent mode uses the previous frame’s state and behaves more like a simulation. Dependent animation includes wind, turbulence, variance, noise speed and speed variation. These controls can create quick surface flows such as droplets running down a character head.

More complex interactions may still require particles and a Node Modifier. For graphic motion or lightweight surface animation, the UV route reduces setup considerably. New tools and workflow changes should always be tested on representative assets before entering production.

The post Cinema 4D 2026.3 Rebuilds UV Editing first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Tl:DR / For those who don’t know the tool: BadFX is a free badedits extension for Premiere Pro and After Effects. Both hosts get media and presets. Advanced tools and scripts remain exclusive to After Effects.

One Panel for the Usual Hunt

BadFX brings stock-media search, text presets and motion presets into Adobe’s editing and compositing applications. Users open the extension from the Window and Extensions menus after installation. The asset browser covers images, video, music, sound effects, GIFs, stickers and animated text. Selecting an item imports it directly into the active project or sequence.

The catalogue with Giphy and Tenor and Unspalsh and so on – is containing millions of royalty-free assets. The attraction is easy to understand. Editors regularly leave the timeline to search several websites, download files, locate them again and import them. Bringing those steps into one panel cuts down the administrative side of video editing, which rarely appears in the showreel.

Stock Without Browser Tetris

The image search connects to Unsplash and Pexels. Video search also uses Pexels. Music and sound-effects searches connect to Openverse, while GIF and sticker searches use GIPHY and Tenor.

Sound effects preview when the pointer moves across their waveform. Clicking an item imports it into the sequence. Music results include a copyright icon that displays the licence type when hovered. Video search accepts descriptive terms and can also supply textures for overlay work. Still images, stickers and animated text follow the same click-to-import workflow. The current interface lacks filters for licence class, aspect ratio and resolution, but apparently this is in the development backlog.

Text Presets With Real Controls

The free text library divides animations into words, lines and letters. Users choose a preset, import it and alter its duration by dragging its edges in the timeline. The Properties panel includes font, colour, alignment, position, scale, rotation, tracking and line spacing. Entrance and exit sections expose additional controls for timing and motion.

Some presets include wiggle settings for seed, intensity and speed. Others include overshoot and swinging controls. Ease-in and ease-out sliders adjust the animation curve without requiring a separate graph editor.

The useful distinction is editability. These are not flattened clips. Artists can adjust typography and motion rather than accepting a baked animation with different words pasted on top. The current workflow does not include a simple switch for disabling an exit animation.

Motion Without Keyframe Archaeology

The motion section applies animation to graphics, stickers and other visual elements. Basic presets cover fundamental moves, while Mix presets combine several properties. Controls cover entrance and exit motion, timing, easing, swinging behaviour and motion blur. Dragging the preset edges changes its duration. This part of the extension targets quick motion graphics rather than elaborate character animation. It supplies a starting point and enough controls to stop every imported graphic from moving in exactly the same way. Motion blur, replacement behaviour and nested-sequence timing still deserve inspection at delivery resolution.

Free Core, Paid Packs

The extension itself is free forever. A free account is required for operation, licence management and delivery of purchased products. Optional paid packs include titles, transitions and other creative assets. The shop describes its transition presets as adjustable and resolution-ready.

Kinetic Titles target energetic work such as online videos, promos and sports edits. Cinematic Titles use a more restrained style aimed at documentaries, corporate films and narrative projects.

Bundled sound can remove another small search from a deadline-driven edit. It can also become repetitive when a pack appears across several projects, so editors should still treat the supplied cue as a starting point rather than sacred audio. A demo pack lets users test a selection of transitions before buying a complete pack. The püricing is between 13$ and 34$, depending on the pack.

Both Regular and Extended licences permit commercial use and prohibit resale or redistribution of the original files. Digital purchases arrive immediately, while refund requests receive case-by-case review. The software licence permits activation on up to two devices linked to one account.

Premiere and After Effects Differ

Media assets and presets work in both supported applications, Premiere and AE. Advanced tools and scripts work only in After Effects workflows. The official walkthrough demonstrates asset browsing, text animation and motion presets. That distinction matters for mixed application teams. “Supports Premiere and After Effects” does not mean both versions contain identical functions.

The product page provides installers for macOS and Windows. It does not publish minimum operating-system versions, minimum Adobe versions, offline behaviour, proxy requirements or central deployment options.

Useful, With Homework Attached

The strongest part of BadFX is the combination of asset search and editable animation inside one panel. The stock browser reduces window switching. The text presets expose more than basic font replacement. The motion section handles routine movement without demanding manual keyframes for every graphic.

The gaps are equally practical. Asset filtering is limited. Some provider and roadmap information comes only from a reviewer. Compatibility requirements and media-storage behaviour remain undocumented on the public product pages.

Studios should test login behaviour, cache locations, relinking, licence records, rendering and project transfer under their real production restrictions.

New tools and innovations should always be tested before use in production.

https://badedits.com/plugin

The post BadFX Packs Assets Into Adobe Panels first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Imagen Video applies automated color correction to sequences from Adobe Premiere Pro and DaVinci Resolve, using AI Profiles or uploaded LUTs, then returns a graded project you can adjust in your NLE.

Imagen Video wants to finish the grade before you finish the coffee

Imagen itself describes the tool as adaptive AI colour grading that matches cameras, fixes skin tones, handles exposure and white balance, and delivers a consistent grade across an entire timeline, clip by clip. It supports Adobe Premiere Pro and DaVinci Resolve, and the export/import workflow is built around processed project files rather than a rendered video roundtrip.

The setup is very clear: speed and convenience. This is not a replacement for a supervised grade on a high-end finishing job. The problem being solved here is not “make this commercial look like it came out of a Baselight room with a senior colourist and three clients arguing about teal.” It is more like: match a pile of mixed footage quickly enough that the project can leave the building before everyone involved loses the will to invoice, because they’ll watch it on a non claibrated tablet anyway.

The company comes from high-volume professional photography, with weddings, events, real estate and similar workflows: many files, repeated looks, tight deadlines, limited appetite for manual correction on every shot.

What the tool actually does

Imagen Video works after picture lock. The company recommends uploading a finalised project, because colour correction is applied to the edit as it exists at upload time. The user selects the sequences to process, including nested sequences, and Imagen uploads the project for cloud processing. When the correction is complete, the user receives an email and downloads a new project file.

Corrections can be applied directly to each clip or as adjustment layers. In Premiere Pro, Imagen applies Lumetri Color effects. In DaVinci Resolve, the result is available as node-based adjustments, so the user can still inspect and refine the grade. The processed project file receives “-with-imagen-edit” in its name, while the source project remains unchanged.

The tool supports two colour-direction methods. AI Profiles are pre-made looks built by videographers, which Imagen adapts across the footage. Think Instagram-Filters. Alternatively, users can upload their own LUTs and let Imagen use them as the basis for adaptive colour correction. The company says AI Profiles can be previewed, adjusted and reused, while LUTs can be treated as technical transforms, creative looks, complete LUTs or combinations of technical and creative LUTs.

Imagen’s LUT workflow is the more interesting claim, at least on paper. The company argues that a normal LUT is static: it applies the same transform to every clip, regardless of exposure, white balance, lighting or camera differences. Imagen says it instead uses the LUT as a reference point, then generates clip-specific corrections that preserve the intended look while adapting to the actual shot. For technical LUT workflows, Imagen says users can upload different LUTs for different camera folders. The required LUT format is *.CUBE.

AI Profiles, sliders and the part where taste becomes a settings panel

AI Profiles can be adjusted before colour correction. Users can “Adjust AI Profile,” move sliders to better match their colour style, then save those changes for the current and future projects using that profile. After processing, users can also provide feedback, adjust the profile again, and trigger an updated correction. Imagen then emails the user when the updated correction is ready.

In Premiere Pro, the help article states that the Input LUT is shown as “Imagen Edit” and the adjusted profile changes are visible in the Basic Correction sliders. That is useful because it suggests the result is not a completely opaque rendered grade. Editors can inspect at least part of what was changed and continue working with familiar controls.

Still, this is where the “filter versus workflow” question sits. Imagen insists this is not a generic filter, but a tool that adapts clip by clip. The technical claim is that the grade responds to footage conditions, not that it simply overlays one look on a whole sequence. Fair enough. But from a production standpoint, it still needs to be judged by the output, not the adjective density of the product page.

Where this gets risky

Colour correction across a timeline is not a small automation task. It touches every cut, every lighting shift, every camera transform, every skin tone, every odd white-balance decision and every “we will fix it in post” moment that should have been legally banned around 2009.

Imagen says it can match cameras, balance exposure, handle white balance, preserve skin tones and adapt LUTs across lighting shifts. Those are substantial claims. If the system guesses wrong, the mistake may not be isolated to one clip. It may be spread across a sequence in a way that only becomes obvious when the edit is watched in context – and already downloaded and paid for.

AI systems can produce confident mistakes. They may show up as skin tone drift across a scene, inconsistent contrast between angles, lifted blacks, crushed detail, a strange warmth shift, or a look that feels coherent in thumbnails and wrong in playback. The first proper review should not happen with the client in the room, unless the workflow also includes ritual humiliation as a billable service (Not judging, you do you)

Roundtrip and checking

The nondestructive workflow helps. The original project remains untouched, the graded result comes back as a new project, and the user can adjust clips in Premiere Pro or Resolve. That makes Imagen safer than a black-box render-only system, like a few we decidedly haven’t written about in the last years of AI-everything. But it does not make it safe by default.

The company recommends starting with a shorter sequence before running a full project. That advice is correct and should be taken seriously, despite being buried in product-guide politeness.

Cloud processing, storage and consent

Videos are stored on AWS servers and used exclusively for the user’s projects within Imagen Video. It also says footage is not used for any other purpose without explicit consent and claims GDPR compliance.

For wedding films and corporate work, this may be straightforward, depending on contracts. For agency jobs, broadcast material, unreleased campaigns, sensitive documentary footage or NDA-bound productions, cloud upload is not a small detail.

Pricing

The product page says the first project can be edited for free without a credit card. The pricing page also states that the free trial includes 20 minutes of colour grading.

The listed launch pricing has two individual plans. Pay-as-you-go is billed monthly, with no base fee, and charges only for processed minutes with € 1 per Minute.

The Starter Pack is listed at 30 dollars per month, includes 50 minutes, and charges extra minutes at 0.60 dollars per minute. Unused Starter Pack minutes roll over as credits.

Also, I found no clear information in the available sources about whether minutes are refunded or not charged if the tool fails to apply LUTs as expected. That is exactly the kind of detail that becomes important five minutes after it costs money.

Practical verdict

If you need a first pass for a showreel, a corporate edit, a wedding film, an event recap or a branded sequence with too many cameras and not enough time, Imagen Video could be useful. If you need a final supervised grade for high-end finishing, this is not it, but, to be fair, they do not really claim that either. Which is refreshing, because normally AI tools promise to replace the department, the client, and probably lunch.

https://imagen-ai.com/video

https://imagen-ai.com/vblog/meet-imagen-video-professional-color-grading-built-for-editors

The post Imagen Video brings AI grading to timelines first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: Houdini is SideFX software for procedural modelling, animation, VFX, look development and rendering. Houdini Engine connects its assets with Maya, 3ds Max, Unity and Unreal Engine.

Before anyone updates the farm

Houdini 22 has appeared in a maddeningly short sneak peek video. That sentence contains nearly everything we can state with confidence. The footage moves quickly through Gaussian Splats, character work, Copernicus, Terrain, USD, Unreal, rendering and simulation. It supplies very little explanation and what follows is therefore guesswork.

Think of it as fanboys pausing a teaser frame by frame and attempting to identify the nodes before the compression artefacts win. A longer presentation is scheduled for June 22, 2026. Until that arrives, every interpretation deserves a large bucket of salt.

The Splats look suspiciously useful

The loudest section of the teaser concerns Gaussian Splats. The video appears to show Splats created inside Houdini, processed through procedural networks, rendered in Karma and manipulated as scene data. It also appears to show a Splat-based creature being rigged and animated. Thank you, SideFX, for picking the absolutely worst animal to trigger all my personal creepy-crawly shrieks. Why not do that with a cat, or a dino, or something …l nice?

But back to the topic: That sounds substantial. It may be substantial. The animated creature suggests that Houdini 22 may support deformation or motion workflows for Gaussian Splat data. The footage also appears to show training or generation through TOPs. So, the Gaussian Splat Machine Learning for Radiance fields directly within Houdini.

Copernicus keeps spreading

Copernicus appears throughout the teaser. The footage shows procedural pattern generation, a UV Shape node, Neural Cellular Automata and image-driven effects moving across geometry. One shot appears to use adjacency data and time shifting to move ripples across a statue. That could indicate tighter links between image processing and surface topology.

Could is doing heavy work in that sentence. Copernicus also appears beside terrain tools and Unreal Engine integration. A Houdini Digital Asset seems to expose COP controls inside the engine. That could become a practical authoring workflow for procedural textures and effects. It could also depend on prepared assets, restricted nodes or specific outputs.

The teaser does not say.

Character tools get a few seconds

The KineFX section appears to include IK Limits and Set Driven Keys. Both concepts are familiar in character rigging. IK Limits restrict joint movement. Set Driven Keys connect one animated value with another. Their apparent arrival in Houdini could simplify common rigging tasks.

Motion Mixer also appears to gain nested clips. The current reading is that animation clips can be nested within larger clip structures. That seems useful for assembling longer motion sequences.

None of these sections lasts long enough to answer the questions a character department will actually ask.

USD wanders into SOPs

The teaser appears to show USD data authored through SOPs. That could give geometry artists another route into scene description without moving immediately into Solaris. The idea makes sense. SOPs already provide a familiar procedural environment for asset construction. Adding USD authoring there could reduce context switching during asset preparation.

The footage does not explain supported schemas, composition arcs, variants, references, payloads or layer management. It does not establish whether SOP-based USD authoring handles complete production assets or a narrower set of preparation tasks.

Quad Remesh may get more rectangular

Quad Remesh appears to gain a Rectangular method. The visual result suggests a more regular grid-like topology. That may help with surfaces that benefit from cleaner directional flow. Automatic retopology demos usually begin with cooperative geometry. Production begins when the mesh has teeth, holes, overlapping parts and a history of questionable decisions. The new mode looks promising.

Terrain enters the Copernicus fog

Terrain tools appear to move closer to Copernicus. The teaser seems to show a unified heightfield workflow inside the image-processing framework. Since heightfields already behave like grid-based image data, the combination is technically plausible.

Effects get recipes and speed claims

The video appears to show prepared recipes for fireworks and magic effects. Recipes can package node arrangements for repeated tasks. That could help artists reach a usable starting point faster.

Voronoi fracturing also appears faster. Faster than what, on which hardware, with what geometry and under which settings remains unknown.

Disclaimer: This is a teaser, not documentation

Hints are not specifications. Several interpretations may turn out to be accurate. Others may describe internal experiments, partial workflows or features that behave differently from the way the teaser suggests. The video is simply too short to support definitive conclusions.

For now, SideFX Houdini 22 looks interesting. That conclusion is safe. Everything more detailed remains guesswork until the manuals arrive.

YouTube Houdini 22 Sneak Peek

The post Houdini 22 Teaser Fuels Guesswork first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Fernando Rivas Manzaneque (LinkedIn) co-founded Volinga AI after completing doctoral-level research in machine learning and radiance fields at the Arquimea Research Center and the Universidad Politécnica de Madrid – see his references on Google Scholar). Under his leadership, Volinga has positioned itself as one of the first companies to offer a production-ready solution for 3D Gaussian Splatting (3DGS) tailored for VFX, virtual production, and real-time workflows, most notably with the Volinga Suite and its companion plugin for Unreal Engine.

DP: Hi Fernando! I made, like, 2,000 pictures of my room. What can I do with that?

Fernando Rivas Manzaneque: Good news: those 2,000 images are basically a goldmine. With 3D Gaussian Splatting, the technology at the core of Volinga, you can turn that pile of images into a fully navigable 3D replica of your room, and you don’t need any 3D background to do it. No manual modelling, no UV unwrapping, no texture painting. You just feed the images in, and the algorithm figures out the geometry and appearance from scratch.

What you’d actually do is load those shots into the Volinga Suite, let it process them, and within a reasonable amount of time, you’d have a 3D Gaussian splat of your room ready to go. From there, you pull it into Unreal Engine with our plugin, relight the whole thing, drop in some sci-fi assets, and suddenly your bedroom is a space station. Or a crime scene. Whatever you’re into.

Here’s the honest part, though: your first result will probably be good enough to get you genuinely excited, and not quite good enough to leave you satisfied. That’s the Gaussian Splatting rabbit hole right there. The entry point is surprisingly low. Getting started requires almost no 3D background. But the ceiling is very high, and the gap between “cool demo” and “hero set on a Hollywood production” is mostly about understanding the capture itself: how you move, how you shoot, how you deal with light and motion. Once that clicks, you can build photorealistic environments that would normally require a full art department, and you can do it without leaving your living room.

DP: Okay, so I load my pictures into Volinga, and Unreal shows me my room on a giant LED wall?

Fernando Rivas Manzaneque:  Pretty much, yes. You load your images into Volinga Suite, our desktop application for creating and editing Gaussian splats, and the software processes them into a 3D asset you can take anywhere.

The output can come in a couple of formats. The most widely used right now is PLY, which is essentially the format that emerged from the original Gaussian Splatting research. It was convenient, it was already there, and the community adopted it quickly. We’ve also developed our own format, NVOL, which carries additional metadata that becomes genuinely useful once you’re inside Unreal Engine: things that PLY simply wasn’t designed to hold.

From there, yes, you can absolutely pipe that into Unreal and send it out through a giant LED wall. I’m glossing over a few things here, learning Unreal, setting up the hardware, the whole VP infrastructure, but that’s not really the Volinga part of the equation.

If you already know how to work in Unreal, and I suspect most people reading this do, then bringing in a Gaussian splat with our plugin is as simple as drag and drop. With the Volinga plugin, 3DGS assets are first-class citizens in Unreal Engine. They sit in the content browser, they respond to the scene, and you work with them the same way you’d work with any other asset in the engine.

What even is Volinga?

DP: So the Volinga Suite does exactly what with my files?

Fernando Rivas Manzaneque: Under the hood, Volinga Suite runs through several distinct stages. First, it locates your images in 3D space. Then it applies lens distortion correction. From there, it generates a sparse point cloud. And once that foundation is solid, it trains the actual 3D Gaussian Splatting model on top of it.

That first part, the image localisation, the distortion correction and the point cloud generation, is what’s known as Structure from Motion. This is where the algorithm goes hunting for patterns across your images: visual features it can recognise in multiple shots from different angles, which it then uses to triangulate positions and solve the combined puzzle of camera placement and lens calibration. This is also where things can go wrong.

Two of the most common culprits are featureless flat surfaces and insufficient overlap between images. If your scene has large untextured areas, a white wall, or a polished floor, the algorithm simply has nothing to grab onto. And if your shots don’t share enough visual information with their neighbours, the whole chain of correlation breaks down.

Shooting technique matters enormously here. What you’re after is parallax: you want to see the same features from genuinely different viewpoints so the geometry can be triangulated properly. That means moving with the camera in translation, not just rotating on your own axis. A common mistake is to stand still and pan. Keep your feet moving, Shift your position, cover the scene from angles that actually differ in space.

Beyond that, a few things will quietly destroy your results. Blurry pixels, whether from motion blur or shallow focus, are trouble. Lens flare is trouble. The reason is the same in both cases: these are single-image phenomena. They don’t exist in 3D. They can’t be explained across multiple views, so the model will try to accommodate them anyway and produce artefacts in the final splat.

The same logic applies to anything that moves during capture. People walking through the frame, objects shifting, and even abrupt lighting changes. 3D Gaussian Splatting models only three spatial dimensions. Time is not part of the equation. Anything that changes between frames ends up as what we call floaters: ghostly smears of geometry that appear to hang in the air with no explanation, because the model invented them trying to reconcile images that should agree but don’t.

If you want a field-tested breakdown of all of this with patterns, environment types and camera settings, one of our artists put together a practical guide on the Volinga blog: Capturing Gaussian Splats: Lessons from the Field.

An Introduction to Gaussian Spalts

DP: We keep saying “Gaussian splats,” but what does that actually mean?

Fernando Rivas Manzaneque:  Gaussian Splats don’t exist in isolation. They belong to a larger family of techniques called Radiance Fields, which has been an active area of research for years. The field really exploded in 2020 with the arrival of NeRF (Neural Radiance Fields) and hasn’t slowed down since.

To understand why any of this matters, it helps to understand what came before. Until recently, almost every reality capture pipeline was built on the same foundational idea: triangulate points in space, connect them, and generate a polygon mesh that represents the geometry of a real scene as accurately as possible. And it works, to a point. The problem is that polygons were invented for modelling the world, not capturing it. They’re a tool designed to give artists control over geometry.

When you flip that purpose around and ask the algorithm to reconstruct reality, you often get results that are decent but rarely ready to use: holes, artefacts, and geometry that needs manual cleanup before it goes anywhere near a production pipeline. That’s not a failure of the tools. It’s just a mismatch between what the tool was designed for and what we’re asking it to do.

Radiance Fields come at the problem from a completely different direction. Instead of trying to build a mesh, they represent a scene as a radiance field: a description of the light emitted from every point in space, and how that light reaches any given camera. The world, in this model, isn’t made of polygons. It’s made of millions of infinitesimal particles that emit light, and the goal is to figure out what those particles look like and where they are.

Here’s an analogy that might make it click. Imagine you’re trying to map the temperature of a lake: not just the surface, but the full three-dimensional volume, deep enough to understand how currents flow. You do it by placing a thermometer at hundreds of different points, at different depths, different locations. The more measurements you take, the more accurately you can reconstruct the temperature field, and the better you understand the currents. You never directly observe the full field. You sample it.

That’s exactly what we’re doing with cameras and Radiance Fields. The camera is the thermometer. We can’t directly measure the light emitted from a single point in space, but we can measure the light that reaches the camera sensor from every point it can see. The more cameras we use, from more positions, the denser our sampling of the radiance field, and the more accurately we can reconstruct it. That’s also why Structure from Motion matters so much: before we can interpret what any camera is seeing, we need to know precisely where in space that camera was sitting.

Now, where does the machine learning come in? The radiance field is an extraordinarily complex mathematical function. Machine learning is, at its core, an extremely powerful function approximator. You give it a set of measurements of some unknown function, and it builds an estimate of that function that fits the data. That’s the NERF approach: a neural network that you can query at any point in space to ask what colour and intensity of light would be emitted there.

Gaussian Splatting changes one fundamental thing in this picture. Instead of a neural network that you have to query for every point in space, including all the empty ones, you get a set of discrete elements, the Gaussians, each of which stores the radiance information for its own region directly. Each gaussian has a shape, a colour, an opacity, a rotation, and these properties are optimised during training until the collection of gaussians together best reproduces what the cameras saw.

Critically, Gaussians exist only where the scene has content. Empty space has no Gaussians. With NeRF, the network had to store information about both the void and the matter. With Gaussian Splatting, you only represent what’s actually there, which is a big part of why rendering is so much faster and more practical for real-time applications.

Volinga Hardware, Workflow & Integration

DP: So, what kind of machine do I need to have this running?

Fernando Rivas Manzaneque: It depends on how long you’re willing to wait. Our latest release will run on your A2000 without breaking a sweat. An RTX 3080 works fine too. The catch is time. Take that 2,000-image example at 2K resolution and you’re looking at roughly a day and a half of processing. Personally, I think that’s completely reasonable. You set it running, you go do other things, and the next morning you have a splat. It’s not instant, but it’s not asking you to babysit it either.

If you want to push things faster, our most frequent users tend to work on an A6000 or an ADA A6000. That’s also the card that tends to show up in virtual production setups, so there’s often no additional hardware investment if the studio is already equipped for that pipeline. The hard minimum is an Nvidia RTX 3000 series or above, and yes, that does mean Nvidia specifically. No way around that one for now.

On the cloud question and the security concerns: everything in Volinga processes locally, on your machine, offline. The only moment you need an internet connection is to validate your credentials at login. And for clients with stricter requirements, we offer offline licences that remove even that dependency. No data leaves the building at any point in the pipeline. We can accommodate both ends of the spectrum, from studios with relaxed policies to those with the kind of security requirements that make IT departments very popular at meetings.

Volinga Practicalities – Cameras, Colours and Clean-Up

DP: So, let’s say I shoot this with my little point-and-shoot camera , 12 megapixels, nothing fancy. How do I make sure that the Unreal scene actually looks like the real place?

Fernando Rivas Manzaneque:  Colour accuracy is something we’ve thought about carefully, because it’s where a lot of tools quietly drop the ball. The short answer to the point-and-shoot question is: yes, it works, but you won’t get the full benefit of the colour pipeline unless you’re shooting with a camera that actually has the dynamic range and colour depth to justify it. A 12-megapixel consumer JPEG will give you a perfectly usable splat. It won’t give you a wide-gamut, scene-referred asset that responds beautifully to relighting in Unreal. That requires more to begin with.

Here’s how Volinga Suite currently handles it. The pipeline has two branches, depending on what you feed it. If you provide EXR files, we assume ACES 2065-1 as the input colour space and treat the data accordingly. If you provide anything else, JPEG, PNG, or standard video frames, we assume sRGB with Gamma 2.2. It’s straightforward and honest about what it’s doing.

For productions that want the full ACES pipeline, the workflow is to take your camera’s RAW footage, convert it to ACES 2065-1 EXR using a DCC like DaVinci Resolve, and feed those EXRs into Volinga Suite (There is a Netflix Technology Ressource explaining how to do that, with a charming accent and everything you need to know on how to do this: ACES Deliveries in DaVinci Resolve – relevant part starts at 7:50).

This gives you a colour-accurate, wide-gamut splat from the start. But it’s worth being honest: this only makes sense if your camera has enough dynamic range and colour gamut to survive that conversion. Running consumer camera footage through an ACES pipeline doesn’t add information that isn’t already there. It just preserves what you had more faithfully.

Where things get more interesting is in the Unreal plugin. That’s where we integrate OCIO properly. Regardless of where a splat came from, the plugin uses OCIO to convert the asset’s colour to the Working Colour Space configured by the user in Unreal Engine. That means the splat respects the project’s colour management setup rather than just landing as a raw texture and hoping for the best.

On ACES 2065 being updated: you’re not misremembering. ACES 2.0 has been released by AMPAS. The 2065-1 colour space itself remains unchanged, so the interchange format is stable. What ACES 2.0 replaces is the Output Transform pipeline, the classic RRT plus ODT combination, with a new unified transform that handles highlights more physically and performs considerably better in HDR contexts. For Volinga’s purposes, the core input handling stays the same. The implications are more on the display and grading side of the pipeline, but it’s good news for anyone building workflows that need to stay consistent across SDR and HDR deliverables.

DP: So, I bring this stuff together, Volinga does its thing,  how do I clean the files up? Can I tweak them inside the Suite or is this done in the Unreal Plugin?

Fernando Rivas Manzaneque: The Volinga Suite includes a built-in editor, and it’s worth spending a moment on what it actually does, because it’s where the difference between a raw splat and a production-ready asset gets made.

The primary purpose is cleanup. Every capture picks up things you didn’t want: floaters, artefacts, background elements, and people who walked through the frame at the wrong moment. The editor lets you identify and remove those without touching the rest of the scene.

Beyond cleanup, you can combine captures. If you shot a space in multiple sessions or captured different environments that need to live together, you can merge them into a single asset inside the Suite. The reverse is also possible: if a single capture contains multiple elements that need to behave independently later in Unreal, you can isolate them as separate assets right here, so each one can be moved, hidden, or manipulated individually once you’re in the engine.

The toolset is deliberately varied because what works best depends entirely on what you’re trying to select and how the Gaussians are distributed in that area. You have brush tools, lasso selection, and volumetric selection using shapes like spheres and cubes. You can also select individual Gaussians directly when you need surgical precision.

There are two visualisation modes to support this. The standard randomised view shows the splat as you’d normally see it. The second mode displays Gaussian centroids and renders each Gaussian as a ring, which makes it much easier to see exactly where one Gaussian ends and the next begins. When you’re trying to make a precise selection in a dense or complex area, that distinction matters a lot.

Once you move into Unreal, the editing options extend further. You can use what we call Cut Volumes to mask out regions of a splat’s content directly in the engine, without going back to the Suite. We also have Proxies, which allow you to edit Gaussian material properties to a certain degree. It’s not full material authoring, but it gives artists meaningful control over how the splat responds to the scene around it.

If you want to see the editor in action, we’ve put together a walkthrough: Volinga Suite Editor.

DP: So, I added a dinosaur into my room, but it looks totally out of place. Shocking, I know. Can we do something about the lights?

Fernando Rivas Manzaneque:  The short answer to the dinosaur looking out of place: yes, we can do something about the lights, and it’s more capable than most people expect.

The Volinga plugin is designed to make Gaussian splats behave like any other asset in Unreal. You add a light source, and the splat responds to it. Change the colour, change the intensity, mix multiple lights: the gaussians react, and everything in the scene stays coherent. This is what makes relighting genuinely useful for virtual production rather than just being a demo feature.

We currently support two relighting methods. The first estimates normals directly from the Gaussian data itself. It works well, requires no additional work from the artist, and gets you most of the way there quickly. The second method lets the user provide a Proxy Mesh, which we use to derive more accurate normals. This produces higher-quality results and gives you more control, but it does require some manual work. That said, it’s nowhere close to the kind of manual effort that traditional photogrammetry cleanup demands.

Now, the shadow question. You spotted a real limitation: Gaussians can receive shadows from other 3D objects in the scene, but they don’t cast shadows onto other elements. It’s one of the current constraints of the approach. The workaround, if you want proper shadow casting, is the Proxy Mesh again. Because Unreal treats the mesh as geometry, it casts shadows correctly, and the visual result reads as expected.

If a Proxy Mesh isn’t an option, whether for lack of time, resource, or skill, contact shadows are a practical alternative. They carry a small performance cost, but they get you believable grounding and interaction between your splat and the rest of the scene without any geometry work.

On-scene complexity and multiple lights: Unreal is extremely good at managing large numbers of light sources, and you benefit from all of that directly. We haven’t reinvented anything here. What we’ve done is make Unreal understand and illuminate Gaussians as a first-class element. Once that translation is in place, everything Unreal can do with lighting, you can do with your splats.

DP: So I just need a camera, the Volinga software, and Unreal Engine, that’s it? Can I use any other 3D tools with Volinga?

Fernando Rivas Manzaneque: A regular camera is genuinely enough to get started, and the previous answers cover how to get the most out of one. But there are other routes into the pipeline, and some of them change the rules of the game considerably.

Our partner Xgrids makes capture hardware specifically designed to reduce the constraints we’ve been talking about. Their devices combine a LiDAR sensor with an IMU, an “inertial measurement unit”, which means that while you’re moving through a space, the device is simultaneously solving its own position in 3D. Structure from Motion is happening in real time during capture, rather than being solved retroactively from images alone. The practical effect is that the strict requirements around parallax and pattern overlap become much more relaxed. They’re still good practices, but they’re no longer make-or-break.

Xgrids devices also come with a companion mobile app that gives you live feedback during capture, showing which areas of the space have been covered and which are still missing. That real-time map changes the capture experience significantly: instead of hoping you got everything and finding out during processing, you can see the gaps and fill them on the spot.

The main limitation with these sensors is on the imaging side. The cameras are 8-bit, and resolution isn’t their strongest point. For most use cases you can work around this with their HD Enhancement feature, Grids Probe, or simply by investing more time in the capture. The output is fully compatible with the Volinga Unreal plugin, so the pipeline stays exactly the same regardless of which hardware you used.

As for which Xgrids device makes sense: it depends heavily on what you’re capturing. The PortalCam is excellent value and particularly well-suited to interiors. For large outdoor environments you’ll cover more ground and may need to swap batteries mid-session, but it handles it. The XLK2 trades a slightly weaker image sensor for a longer-range LiDAR, which means fewer passes needed to cover a large space. If you’re working on expansive environments, that trade-off often makes sense.

On 360 cameras, Insta360 and similar devices, as well as certain drone setups, are producing genuinely promising results. The limitation there is sensor size relative to the field of view: you’re covering a lot of angles at once, but the detail in any given direction suffers for it. The practical fix is to add closer, more targeted passes over the areas that need finer detail. For a quick capture or a previz-quality environment, 360 solutions are hard to beat. For a hero set, they work best as a starting point that you refine.

Production Realities: Capture, Errors & Unreal Integration

DP: So, let’s say I had a big run-around in the room with the PortalCam. I did that, imported it into Volinga, it did its thing, I cleaned it up, now I have a perfect 3D version of my room. Hopefully I didn’t move anything during shooting. How much space for errors is there in the data?

Fernando Rivas Manzaneque:  Film sets are chaotic by nature, and Gaussian Splatting is not entirely forgiving of that chaos. But there’s more room to manoeuvre than you might think, and the tools exist to fix most of what goes wrong.

The good news first: Structure from Motion is quite resilient to occasional bad frames. If a person walks through the background in three shots out of two hundred, the algorithm has enough consistent data from the rest to effectively outvote those frames. The reconstruction will handle it. The same logic applies to minor lighting shifts. A handful of inconsistent images in a large dataset will usually just produce a small amount of noise or a faint floater in that area, rather than breaking the whole reconstruction.

Where things get harder is when the problem is systematic rather than occasional. If lighting changed significantly halfway through a capture session, if an object was in one position for the first half and a different position for the second, or if a large area of the set was consistently obstructed, the model has genuinely contradictory information and will invent geometry to reconcile it. That’s where you get the floaters we mentioned earlier, and no amount of processing will resolve a fundamental inconsistency in the source data.

The Volinga Suite editor is your main tool for dealing with what slips through. Artefacts, floaters, ghost geometry from people or objects that moved: these can all be identified and removed in the editor without touching the rest of the scene. For a film set context, a good workflow is to treat the first pass through the editor as a deliberate cleanup step, not an optional one.

What the editor cannot do is invent information that wasn’t captured. If you missed an angle, that gap is real and it will show. The solution there is to go back and capture it. With devices like the Xgrids PortalCam and its companion app, you can catch those gaps during the session itself, before you’re back in the office and the set has been struck. That real-time coverage map is genuinely useful on a production where time on set is limited.

The practical advice for anyone working in a live production environment: lock down what you can, capture with enough overlap that individual problem frames don’t matter, and use the editor to clean what you couldn’t control. The system is more forgiving than old photogrammetry pipelines, but it still rewards discipline during capture.

DP: So let’s say the pipeline works, everybody knows what to do, and somebody taped the DOP and the gaffer into their corners so they don’t move around the set. In your experience, how long should I plan to scan or capture the set or location?

Fernando Rivas Manzaneque: Honestly, this is one of the hardest questions to answer straight, because it really does depend.

The most instructive example I can point to is the work the CBS VFX team did with us on productions including The Neighbors, Frasier, and NCIS. They built a custom five-camera rig using Nikon D850s, which effectively let them capture five angles simultaneously instead of one. With that setup, they were consistently getting episodic TV sets done in around ten to fifteen minutes of capture time. That’s a room-sized set, production-ready quality, taped and out of the way before the crew notices you were there. You can read the full breakdown of how that pipeline came together on our blog.

And here is an Example from the Frasier production. Guess which side is the splat!

For a solo operator with a PortalCam, you can move fairly quickly. A single interior space, covered with enough overlap for a clean previz or a solid reference environment, is realistically fifteen to twenty minutes of walking. If that’s all you need, you’re done before lunch.

The numbers start climbing when the space gets larger or when you’re going for hero-set quality. A detailed, complex interior with fine geometry, clean edges, and no gaps to clean up in post can take two to three hours of capture, sometimes more. Large outdoor environments can go further still. There’s no dishonest way to say it: the quality ceiling is high, and reaching it takes time on set. How much time it takes depends on the space, the target quality, and, honestly, how much care the person with the camera is willing to put in.

The encouraging part is that the entry point is low. You can have something genuinely useful in under half an hour. Where you go from there is a question of ambition and available time, which on a production is usually the same thing

DP: And when the splats get serious, can Volinga handle parallel processing?

Fernando Rivas Manzaneque: Parallel processing is possible, with one important clarification on what that actually means in practice. You can absolutely run multiple splat training jobs simultaneously across different machines. What you cannot do is split a single splat and train it on multiple machines simultaneously. Each job runs on one machine from start to finish.

So if you have a large environment that needs to be broken into sections, the workflow is to do that division upstream, using a tool like RealityCapture to split the scene, and then send each sub-splat to a different machine. Different operators can manage different sections in parallel, and the resulting assets can be combined later in the Volinga Suite editor. It adds a step, but it scales.

For studios managing multiple projects or locations at once, Volinga Suite includes a Job Queue Manager. You line up everything you need to process, launch the queue, and walk away. The machine works through the list overnight or over a weekend without anyone needing to babysit it. For a team running a busy shoot schedule, that’s a meaningful quality-of-life feature.

At the Enterprise level, we offer more scalable deployment options that can integrate with a studio’s existing render farm infrastructure. The specifics depend on the setup, but the goal is to fit into the pipeline rather than sit next to it.

On the question of tiers more broadly: the Personal plan is focused on the Unreal plugin. If you’re an independent artist who already has splats and wants to bring them into Unreal, that’s the entry point. The Suite, with its full processing and editing capabilities, comes in at the Studio level and above.

And yes, we’re working on an automatic end-of-day shutdown feature for public broadcasters. Legal told us we might have to call it something other than “go home, it’s seven o’clock,” but the functionality is basically the same.

DP: How big are these splat files anyway?

Fernando Rivas Manzaneque: File size in Gaussian Splatting is primarily a function of the level of detail you’re capturing, not the physical volume of the space. That distinction matters, and a couple of examples make it concrete.

We have an auditorium in our sample projects that weighs around 800 MB. It seats three to four hundred people, includes a full orchestra setup on stage, and has solid detail throughout, though it’s optimised as a background environment rather than something you’d push into close-up. Contrast that with an abandoned workshop, roughly 40 square metres, which comes in at around 2 GB. It’s a fraction of the physical size, but it’s dense with fine detail across every surface.

Up to about 5 GB, our plugin handles assets comfortably. Once you start capturing larger environments, full city blocks, entire backlots, files can reach 10 to 15 GB, and that’s where things currently get harder. Real-time performance starts to degrade, and we’re actively working on improving how the plugin handles those larger assets. It’s one of the areas where the technology is still catching up with what productions want to throw at it.

DP: So, now the splat is fine. What do I do with it?

Fernando Rivas Manzaneque: Once the Volinga Suite has finished processing, you export the result as either a PLY or our native NVOL format, which carries additional metadata useful downstream.

From there, the path into Unreal Engine is about as straightforward as it gets: you install the Volinga plugin, drop the file into your content browser, and drag it into the scene. At that point, it behaves like any other Unreal asset. You can position it, relight it, combine it with other geometry, and send it out through whatever Unreal-based VP pipeline you’re using.

DP: Why is that a plugin, actually?

Fernando Rivas Manzaneque: Unreal Engine doesn’t natively understand Gaussian Splats. Despite all the noise the technology has been making, and there’s been a lot of it, there’s no built-in 3DGS support in the engine yet.

There are approaches that attempt to represent splats using Niagara particle systems inside Unreal, but they’re significantly limited: relighting is constrained, file sizes become unwieldy, and the visual quality suffers at scale. Trying to bake splats into meshes produces noisy, artefact-heavy geometry that doesn’t hold up in production.

Our approach is different. We render in parallel alongside Unreal’s own rendering pipeline, using texture sharing to pass the splat data into the engine without going through geometry. This means we preserve the full visual quality of the Gaussian Splat while retaining almost all the benefits of working inside Unreal: the lighting system, the compositing, the real-time performance. It’s less of a conversion and more of a handshake between two renderers running side by side.

DP: So if the plugin just takes the splat file and hands it off to the engine, could I use splats that I made in PostShot, RealityCapture, or some other tool?

Fernando Rivas Manzaneque:  Yes, and that’s very much by design. The goal has always been an open ecosystem, not a closed one. The Volinga Unreal plugin will load PLY files from other software, provided the vendor’s own licensing allows export in that format. RealityCapture, for instance, doesn’t generate Gaussian Splats at all, so that’s not a pipeline question. But tools like PostShot or other 3DGS training software that export standard PLYs work fine with the plugin. You can capture and train your assets wherever makes sense for your workflow and bring them into Unreal through Volinga.

DP: Let’s say Unreal finally understands my splat. I’ve got my virtual stage, and I’m blasting it out through LiveFX or whatever flavour of Unreal-based VP tool we’re using today. Now something changes, as it always does. Can I round-trip that data back to Volinga?

Fernando Rivas Manzaneque: The honest answer here is: some things are fast, and some things hit a wall. Relighting is the easy one. As we covered, the Volinga plugin integrates splats into Unreal’s lighting system, so if the brief changes and you need to shift the look of the environment, you work with Unreal’s lights directly. No round-trip required, no re-export, no waiting. That part is genuinely fast enough for on-set iteration.

Geometry cleanup is also manageable. If something needs to be removed or adjusted, you go back to the Suite, make the edit, re-export, and reload in Unreal. It’s not instant, but the pipeline is short enough that it’s a realistic option between setups rather than something that derails the day.

Where you hit the fundamental limitation of the technology is texture editability. A Gaussian Splat bakes the appearance of a scene into the Gaussians themselves. There’s no texture map to swap out, no material layer to override in the traditional sense. What the camera saw is what you have. You can’t repaint a wall or change a logo on a prop after the fact, the way you might with a photogrammetry mesh and a texture atlas.

The workaround, and it does work, is the ProxyMesh approach we mentioned in the relighting section. By associating a proxy mesh with a splat, you get access to material overrides that can drive changes in how the surface responds to light and how it reads visually. But this requires pre-production planning.

You need to have built the proxy and set up the material relationships before you’re standing on the brain bar at two in the morning wondering why the set looks wrong. If that groundwork is in place, you have meaningful flexibility. If it isn’t, your options are more limited.

The practical takeaway for a VP supervisor is: plan for the splat’s editability constraints the same way you’d plan for anything else that can’t be changed on the day. Relighting is yours to play with freely. Anything more structural needs a workflow decision made before the shoot, not during it.

For the Curious and the Budget-Conscious

DP: So, I have my pictures, how do I get the Volinga Suite?

Fernando Rivas Manzaneque:  There’s a free version for non-commercial use, which is the right place to start. It includes both the Suite and the plugin, with a watermark on the output. For anyone doing R&D, testing the pipeline, or just trying to understand whether the technology fits their workflow, it gives you full access to the toolset without any financial commitment.

For learning materials, we have our documentation at docs.volinga.ai, which covers the full pipeline from capture to Unreal. And our blog at web.volinga.ai/use-cases is where we put case studies, workflow breakdowns, and practical how-tos from real productions. If you want to understand how other teams have integrated this into their pipelines before building your own, that’s the place to start. If you want to have an Unreal Scene to play around with: We have a few samples for free, on our website HERE.

DP: Let’s say you’ve convinced me. How much of my budget should I set aside for the Volinga part of the pipeline?

Fernando Rivas Manzaneque: Our strong preference is that people try everything end-to-end first, with the free non-commercial version (Create a free account, downmload all the parts, plus demo material). The full pipeline, Suite to plugin to Unreal, is available without cost for R&D purposes. That’s intentional. We’d rather someone spend a few weeks genuinely understanding how Volinga fits into their workflow before they make any purchasing decision. By the time they come to us commercially, they know exactly which tools they need and why. If you need a single-page-thing for your C-Suite: here is a ultra-short introduction as a PDF.

On the numbers: it depends heavily on how many seats are required and which combination of tools makes sense for the studio. As a starting point, a single Suite licence plus plugin is in the region of €2,000 per year. For studios scaling up across multiple operators or integrating into larger production pipelines, the conversation moves to the Studio or Enterprise tiers, and at that point, it’s worth talking to us directly about what the pipeline actually looks like.

There are a few different versions: The Volinga Plugin has PLY Rendering in UE, Relighting, Post-Process and DoF, Multiple 3DGS Models and Executable Project Shipping.

The “Plugin Pro” has all of that, plus CULL Volumes, HDR and ACES support, nDisplay Support, Color Correction Region Support, Mesh Support and talks to RenderStream, Aximmetry, and LiveFX.

And the Suite for Studios and Enterprise does HDR and ACES pipeline support, 4K and 8K processing, has the Job Queue Manager as well as Reality Scan and Metashape camera registrations imports. And yes, you can try all of that for free.

Scaling Up, Surviving Production & the Occasional Cat Scan

DP: So, what happens when we go big? Let’s say we’re not talking about a room anymore but a full set, a back-lot, or an outdoor environment. How well does Volinga scale?

Fernando Rivas Manzaneque:  The performance envelope we’re most comfortable with right now is up to around 5 GB on a well-equipped workstation, an A6000 or equivalent. Within that range, the plugin handles assets without meaningful degradation. The auditorium and workshop examples from earlier both live comfortably in that space.

Where things get harder is when you start capturing environments at the city-block scale. Those assets can reach 10 to 15 GB, and at that size, the real-time performance starts to feel the weight. It’s not a wall, but it’s not effortless either. We’re actively working on it. Level-of-detail (LOD) systems and spatial partitioning are both on the roadmap, specifically to address this, so the ceiling will move.

But right now, if you’re planning a production around very large outdoor environments, it’s worth having that conversation with us before you’re standing in front of an LED wall, wondering why the frame rate dropped.

DP: What happens if I want to bring my splats into another DCC,  say, Blender, Houdini, or Nuke for compositing or lighting?

Fernando Rivas Manzaneque:  The short answer is that the ecosystem is moving fast, and the PLY format is doing a lot of the heavy lifting. Blender already has plugins that handle PLY import, so bringing splats into a Blender scene for compositing or reference is feasible today. For Houdini, the GS Ops plugin is genuinely good and worth considering if your pipeline runs there. Nuke has had PLY-based plugins for a while, and more recently, Nuke added native Gaussian Splat support through USD, which is a significant step.

On our side, USD integration is on the Volinga roadmap. The goal is to make sure that what you build and process in the Suite can flow directly into Nuke and other USD-capable tools without additional conversion steps. We see Unreal as the primary rendering destination for now, but the intention has always been to stay interoperable rather than become a closed system.

DP: So, what’s the production-readiness verdict? If I were a VFX supervisor trying to convince my producer this will actually work, what would you tell me?

Fernando Rivas Manzaneque:  My honest verdict: production-ready, particularly for virtual production. Not experimental, not a proof of concept you’d bring to a shoot and hope for the best. Production-ready.

The most significant project we can point to right now is Netflix’s Berlin and the Lady with an Ermine, produced by Vancouver Media, the team behind Money Heist. The production needed to shoot a nighttime sequence along Madrid’s Calle Alcalá, combining large-scale stunt work with intimate close-ups of two characters. The close-ups were shot on a virtual production stage with Gaussian Splats of the real location as the backdrop, and the final edit is seamless. The audience cannot tell which shots were on location and which were on the LED wall. You can read the full breakdown here, and if you want to see it for yourself, it’s on Netflix now, Episode 1, minute 32:20.

Beyond that, we’ve worked with CBS VFX across multiple episodic productions, with Envidio, and with a number of other productions that haven’t been announced yet. The headaches we’ve hit along the way are mostly the ones we’ve already talked about: capture discipline, colour pipeline setup, and the editability limitations of splats. None of them are dealbreakers once you know they’re coming. The teams that plan for them consistently get results they’re proud of.

DP: You’ve got to have at least one story of when something went completely off the rails. What’s the weirdest or most chaotic capture session you’ve seen someone attempt with Volinga?

Fernando Rivas Manzaneque:  There’s one that comes up more often than you’d expect, and it’s become something of an informal rite of passage for anyone new to the workflow.

Gaussian Splats capture everything the camera sees. That includes mirrors. And reflections in mirrors are, by definition, pointing back at the person holding the camera. We’ve had more than one capture session where the artist doing the walkthrough forgot to account for this, walked through a bathroom, a dressing room, or any space with a well-placed mirror, and later discovered that they had very thoroughly documented themselves in a state that was not quite production-appropriate. The splat doesn’t judge. It just captures.

The lesson, now standard in any capture briefing we give: treat every reflective surface in the space as a camera pointed directly at you. Dress accordingly. We’ll leave it there.

DP: And finally, what’s next for you and for Volinga?
Fernando Rivas Manzaneque: A few things we can talk about, and a few we can’t yet. On the research side, the field is moving extremely fast and we and our partners intend to stay at the front of it. One of the directions we’re most excited about is 4D Gaussian Splatting, which extends the model into the time dimension and opens up possibilities for capturing dynamic scenes rather than static ones. Getting that into Unreal is something we’re working towards.

Scalability is the other major engineering focus. We’re building our own level-of-detail system and spatial partitioning specifically to overcome current size limitations. The goal is to make large outdoor environments as manageable as interior sets are today.

And on the Suite side, the direction is towards more AI-driven workflows that give artists greater control and editability over their splats. The fundamental constraint of splats right now is that they bake the appearance at capture time and resist change afterwards. We want to change that, gradually but meaningfully, through tools that feel native to a production workflow rather than requiring a research background to operate.

Follow us on LinkedIn, and get a heads up on what happens!
https://www.linkedin.com/company/volinga/posts/

The post Splat happens: Volinga 3DGS workflow for Unreal first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: Mush3D is a GPU-accelerated finishing tool for animated caches. It imports Alembic data from other DCC applications, then adds sculpting, corrective deformation, transfer and simulation before downstream use.

Surgery after animation

Mush3D 3.0 runs the awkward stretch between approved animation and a finished deformation result. Artists can load an animated geometry cache, sculpt directly on the moving surface and add simulation or transfer operations without returning to the original character rig.

The application works with animated meshes rather than limiting its sculpting tools to static geometry. Its workflow covers final polish, facial corrections, deformation cleanup, secondary motion and other shot-level adjustments on cached animation.

A recurring shoulder collapse, an elbow that loses volume or a facial transfer that pinches at particular expressions can be addressed on the cache itself. The artist works on the delivered motion rather than rebuilding the setup that generated it. The software uses GPU acceleration for interactive deformation. It runs as an online application and as a standalone desktop application for Windows, Linux and macOS. Both access routes use the same account and licence system.

Sculpt the moving target

The sculpting system works directly on animated caches and supports multi-resolution editing. It can reconstruct subdivision levels from cached animation, allowing an artist to work at different mesh resolutions while keeping modifications on a shared layer across the mesh stack.

That gives the tool a job closer to shot finishing than conventional asset sculpting. The input already moves. The task is to repair, reshape or enrich that movement without treating every frame as an unrelated static model. Sculpting brushes can change the animated surface, while cloning tools transfer surface detail from other meshes. Earlier versions already allowed corrective shapes to be sculpted on individual frames and their intensity to be animated across the timeline. The cache workflow also avoids tying the finishing pass to a particular source DCC. Geometry usually enters through Alembic, while the free tier limits exchange to OBJ. Paid tiers add Alembic import and export. Core sculpting remains present in the free edition. More specialised deformers, desktop access, project history and Alembic exchange sit in the paid plans.

Pose Trainer learns the fixes

The new Pose Trainer deformer applies example-based correction to animation caches. Artists prepare a set of reference poses, either by sculpting them manually or by using captured 3D data, then train the deformer on those examples. The resulting corrections can run across the animation cache. This targets deformation errors that recur whenever a character reaches similar poses, without requiring the original rig to be rebuilt.

A pre-sculpted pose can define how the surface should look when the underlying motion reaches that condition. The trained system then applies the learned correction to matching portions of the animated cache.

Pose Trainer also works with facial animation. The tool can improve facial 4D transfer between different characters by learning target-specific corrections intended to retain expression volume, silhouette and sculpted form.

The same mechanism can clean up transferred expression libraries. Artists can use cloning tools on FACS and blend shape sets when the transferred shapes need manual correction. This places Pose Trainer between raw transfer and the final animated cache. It does not replace the source animation, but modifies the resulting deformation through trained corrective examples.

Tetrahedra enter the tissue

Version 3.0 adds a tetrahedron-based deformation system for secondary motion in muscles, fat and other soft tissue. Artists paint a mask over the surface region that should receive the effect. The solver creates a tetrahedral volume beneath that selected area and uses it to deform the animated surface.

The mask keeps the operation local. A character does not need a tetrahedral volume across its entire body when only a neck, abdomen or other soft region requires additional motion. That makes the new solver part of the tool’s established simulation workflow. Existing deformers include Jiggle, Wrinkle and Transfer Shapes, alongside the Sculpt Deformer and the new Pose Trainer.

The tetrahedral solver does not appear in the free plan. It is included in Indie, Pro and Enterprise subscriptions, together with skin wrinkle simulaiton and the other paid deformers.

Wrinkles without a dermatology degree

The skin-motion system lets artists mask areas of a character and generate dynamic wrinkles and surface movement from the animated performance. This follows the same regional approach as the tetrahedral solver. The artist chooses where the deformation should occur rather than applying a global simulation to the entire cache.

Jiggle deformation remains available for secondary motion, while Transfer Shapes moves deformation information between meshes. These tools share the central cache-based workflow: import animation, isolate the area that needs attention, apply a deformation layer and export the adjusted result.

Facial transfers get a repair pass

Facial transfer can expose differences between source and target characters. Proportions, expression shapes and surface volume may not survive a direct transfer unchanged. The facial workflow in version 3.0 uses Pose Trainer to learn corrections for the target character. Artists can prepare corrected examples and apply the trained result across the transferred animation cache.

No supported external training frameworks, runtime engines or model formats are named, and no API details appear on the page. Software API access is listed as an Enterprise feature. The supported API functions, programming language and integration targets are not specified.

Web app or desktop seat

The software can run through a browser-based web application or as a standalone desktop program. The web application uses account-based access. Paid plans include a web workspace and project history, while the free plan includes signed-in application access and an account dashboard. Paid subscriptions also include a desktop licence. The standalone build supports Windows, Linux and macOS.

Licences, billing and machine activations are managed through the account dashboard. Existing users of version 2.0 retain separate access to legacy accounts and downloads through the older service.

Four plans and one revenue line

The Free plan costs $0 per month (That’s why it is called free)). It includes account access, OBJ import and export and the core sculpting tools. It does not include Alembic exchange or the paid deformers.

https://mush3d.com/pricing

The Indie subscription targets artists and companies with annual revenue below $100,000. It costs $29 per month or $290 per year. Indie includes the web workspace, desktop licence, project history, Alembic import and export, Sculpt Deformer, Wrinkle Deformer, Jiggle Deformer, Transfer Shapes Deformer, Pose Trainer, tetrahedral simulation and skin wrinkle simulation.

The Pro subscription targets companies with annual revenue above $100,000 that use the software in production. It costs $98 per month or $980 per year. Pro contains the same listed creative tools as Indie and permits commercial use above the $100,000 annual revenue threshold.

The Enterprise plan costs $149 per month or $1,490 per year. It adds floating seats, team licence management, an offline activation manager, a licence-manager server and software API access. All three paid plans are subscriptions. No perpetual licence.

Alembic does the handoff

Paid editions use Alembic for animated geometry import and export. That keeps the application outside the source DCC while preserving access to moving mesh data. The free edition exchanges OBJ files instead. OBJ carries geometry but does not provide the full paid Alembic animation-cache workflow described for production use.

One layer, several resolutions

Multi-resolution cache sculpting addresses a specific problem. Animation caches may arrive at one resolution, while an artist needs access to broader forms and fine surface detail during correction. The software reconstructs subdivision levels from the animated cache. Artists can move between resolutions while keeping changes on a shared layer across the mesh stack. That shared layer lets broad edits and detailed surface work belong to the same modification structure.

Cloning tools can transfer surface detail from other meshes. The same cloning approach supports correction of FACS and blend shape transfers between different faces. These controls place manual sculpting beside the automated deformers. Pose Trainer handles repeated pose-based corrections, tetrahedral deformation adds larger soft-tissue motion and sculpting remains available for shot-specific work that needs direct artist input.

New tools and workflow changes should always be tested on representative assets before entering production. A troublesome shoulder from an actual show will reveal more than a beautifully behaved demo creature.

• Mush3D 3.0 release article
• Mush3D product page
• Mush3D pricing

The post Mush3D 3.0 Adds Soft Tissue Tools first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

NukeRef adds a PureRef-like reference board directly inside the Nuke Node Graph. Copy an image, hover over the DAG, paste, and the image appears as a clean reference backdrop under the cursor.

The tool comes from Denis Rychkov and targets the usual reference problem in comp: screenshots, lookdev frames, texture grabs, paint notes, and client-provided “can you make it more like this” images usually live outside the node graph. NukeRef pulls them into the working space instead of asking the artist to split the screen or jump between viewers, browsers, and image boards.

What it actually builds

The script creates reference images as regular BackdropNode objects. Each reference backdrop stores its position, size, and metadata, then renders the image through two paths. The native path uses BackdropNode.setCustomIcon, which also feeds the DAG mini-map. The overlay path uses a transparent QWidget attached to the DAG window and paints the image with Qt for Python. On macOS, the script enables the Qt overlay because the Node Graph is treated as a stable native widget named DAG_Window. On Windows, the script disables that overlay path and relies on the native custom icon route, because the code identifies the DAG as a volatile GL widget. That is the kind of boring implementation detail that becomes very exciting when a tool does not explode mid-shot. The script imports PySide2 first and falls back to PySide6. It also imports shiboken2 or shiboken6 for Qt object liveness checks. That matters because Nuke UI widgets can disappear while scripts still hold Python wrappers. Dead wrappers are where “works on my machine” goes to retire.

Paste first, ask questions later

NukeRef binds Paste Reference to Ctrl+V in the Node Graph. Copy an image from a browser, Photoshop, or the operating system clipboard, then paste in the graph. The script reads clipboard image data first. It also accepts local image file URLs if the extension matches png, jpg, jpeg, tif, tiff, or webp. When the clipboard does not contain an image, the script delegates back to normal Nuke node paste behaviour. That means regular copied nodes should still paste as nodes, not become collateral damage in the reference-board revolution.

Copy Reference binds to Ctrl+C. When exactly one NukeRef backdrop is selected, it copies that reference image back to the system clipboard. If the selection contains anything else, the script falls back to native node copy. This is qutie civilised for a shortcut override.

Saved next to the script

NukeRef requires a saved Nuke script before it can store pasted image data. Unsaved scripts trigger a message asking the user to save first, because reference images are written beside the .nk file. The storage folder is named nuke_ref_images and sits next to the Nuke script. Pasted clipboard images are saved as PNG files with timestamped names. Local image paths can also become reference backdrops. That design keeps the .nk file small because the script stores paths and metadata on the backdrop instead of cramming image payloads into the node graph. It is also the reason references travel with the shot folder rather than a screenshot lost in Downloads, which is where production evidence goes to become folklore.

Aspect ratio, mini-map, and resize behaviour

The script records each source image’s native width and height on hidden knobs. When an artist changes bdwidth, the knob callback recalculates bdheight from the stored native dimensions. The default reference width is 400 DAG units, or the source width if the image is smaller. The code creates the BackdropNode, centers it near the cursor position, sets the display size, hides the normal backdrop label by setting a tiny note font size, and stores the source path and native dimensions in invisible knobs.

The mini-map support comes from the native custom icon path. The overlay can make the main DAG view cleaner on macOS, but the mini-map sees the native BackdropNode icon. That is a practical split: pretty drawing in the graph, native visibility in the navigator. During resize, the script records a short timestamp and dims the overlay to 30 percent opacity for 0.20 seconds after bdwidth changes.

Installation is old-school

Installation uses the familiar .nuke folder route. Copy nuke_ref.py into the local .nuke directory, then add import nuke_ref and nuke_ref.install to menu.py. Restart Nuke, copy an image, hover over the Node Graph, and paste with Ctrl+V on Windows or Linux, or Cmd+V on macOS.

Price and license

The tool is free. The release note mentions an MIT License, but the uploaded script and setup guide do not include MIT license text.

https://www.linkedin.com/feed/update/urn:li:activity:7465470321228300289

https://drive.google.com/drive/folders/1-MiiUsfbJiyCvxZFy3eeAvuh6nrM6tqI

The post NukeRef Adds References to Nuke first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: Pilgway makes 3DCoat for sculpting, retopology, UVs, painting and rendering. It connects to Blender, 3ds Max and Houdini (and LightWave) via applinks. 3DCoatTextura is the texture-focused sibling.

GPU paint, finally with nodes

3DCoat 2026 is now in public beta for Windows, and the big change is GPU Per-Pixel Painting. The new system adds a procedural Node System for UV-based, non-destructive texturing and lets artists create materials, masks and effects in a visual Node Editor. Parameters such as rust intensity, base color, glossiness and scratches remain editable during work, with real-time viewport feedback on the 3D model.

For artists who have spent years painting a layer, committing to it, regretting it, duplicating it, hiding it, naming it “final_final_02_nowforreal_b”, and then crying softly , this is the headline feature. The workflow moves more of the material logic into editable graphs. The development thread labels the build as an early beta and says it is not recommended for production environments. Believe the developers when they say that!

What the Node System does

The system uses GPU nodes and dynamic compilation into optimized shaders based on NodeGraph Language, or NGL. Procedural operations, mathematical operations and noise generators run directly on the GPU. That matters for texture artists because procedural work can become very chatty. Every mask, noise, curvature blend and dirt pass adds another little gremlin to the stack.

The documentation lists a full Node System with Node Editor, Node and Object Inspectors, Node Graph, NGL, GPU Nodes, Filters, Masks, Materials, Modifiers and Volumes. The GPU Texturing documentation also lists Per-Pixel Painting and PBM Channels.

The docs describe PBR texturing in 3DCoat around Albedo, Depth, Glossiness and Metalness channels. Painting can modify multiple material channels with one brush stroke. The new node system now sits beside that painting logic, rather than replacing the idea of channel-based texture work.

New smart materials, new smart masks

The 2026 beta introduces NGMaterials, NGMasks, NGModifiers and NGFilters. NGMaterials are procedural smart materials. NGMasks generate procedural wear, dirt and scratches. NGModifiers and NGFilters handle geometry deformation and procedural post-processing of current layers. The new materials support approximately 30 channels.

Procedural texturing in a painting app is always a balancing act. Artists want control without turning every barrel, robot arm or old pipe into a PhD in graph management. The Object Inspector tries to keep that sane. Parameters can be pinned from the node graph to general object or layer controls, so a material can expose useful sliders without making the artist dive into the full graph every time.

The UI adds a Node Editor, Node Inspector and Object Inspector. Node header colors are now category-based in the 2026-03 NS Beta. New nodes are created at the position where the right mouse button opened the menu, not where the cursor happens to sit when the menu action finishes.

Layers still matter

The new graph workflow does not remove the old layer habit. The beta adds the ability to select multiple painting layers, move selected layers within the painting layer tree, and group, hide, unhide, duplicate or delete them.

In GPUPPP mode, layer masks use brightness rather than relying exclusively on transparency. Normal Map Support appears in node-based materials in the 2026-03 NS Beta. A crash when clearing the Node Graph in the Node Editor has been fixed, and rectangle or CTRL selection of multiple nodes has also been fixed.

The 2026-02 preview also allows image reading and writing formats to be replaced via Python extension. Objects created by C++ functions from Python scripts will not be garbage collected by Python, avoiding double freeing.

Fabric, fur and soft displacement

The 2026-03 NS Beta adds a Soft Displacement property. The changelog describes it as a displacement effect designed to work with a normal map. It shifts vertices without affecting shading, reduces its shadow impact by half, and uses the normal map to define pixel orientation for shading.

SoftDisplacement combined with Sheen can simulate fur, while FWSNormal defines its direction. For PPP texturing, Show Displacement Mesh must be enabled and tessellation must be configured.

Retopo and modeling also get crumbs

The headline belongs to 3D texture painting, but the beta also touches retopo and modeling. The 2026-03 NS Beta adds an option in the Retopo and Modeling Room: Switching Pen Mode to Rectangle After the Select Transform Activated. Polygon Tree has been improved for speed with large files.

The Sculpt Room gets speedups for Blob tool filling in Smart Hybrid and a new lasso placement option for the Blob tool in Smart Hybrid. Live booleans get a crash fix when unghosting. STL import fixes address overly small scale on import.

3DCoatTextura’s learning mode keeps saving and loading in the internal .3b format, with a limitation of 10 layers and render watermarks. OBJ export remains available with limits: 4000 triangles from the paint room and texture export up to 512 by 512 without watermarks, or higher resolution with watermarks. Commercial use is not allowed for that free learning-mode output.

Pricing, because artists own wallets

The official 3DCoat buy page lists 3DCoat 2025 Individual Node-locked at €379, VAT not included. It is a permanent personal license, allows commercial use, works as a platform-independent license and includes 12 months of free updates.

The same page lists subsequent updates at €45 from month 13 onward after purchase, or €90 from month 25 onward if the €45 upgrade was not made, with another 12 months of free updates.

Bottom line

The best news is not just “nodes”. The useful news is that the system connects to painting layers, masks, smart materials and viewport feedback. That is where texture artists actually live.

The caution flag is equally clear. The build is beta, Windows-only in its current public form, and explicitly not recommended for production environments. Test it, break it, report the boring bugs, and do not bet a delivery on it yet. The graph may be shiny, but the deadline goblin remains undefeated.

https://3dcoat.com/forum/index.php?/topic/34175-3dcoat-2026-gpuppp-development/

The post 3DCoat 2026 gets GPU nodes first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: DaVinci Resolve combines editing, Fusion, colour grading and Fairlight audio post. Version 21 also adds still-image processing.

Final, mostly familiar

Resolve 21, Fusion, Fairlight Live, and many, many boxes!

Blackmagic Design has released DaVinci Resolve 21 for Windows, macOS and Linux. The release converts the features developed through four public betas into the final 21.0 branch. Most headline additions arrived in the first beta. These include the Photo page, AI IntelliSearch, Speech Generator, CineFocus, MultiMaster trim passes, expanded keyframing, Fairlight folders and more than 70 Krokodove tools for Fusion. The initial feature set appeared in our NAB overview and our closer look at the Photo page.

What the betas added

Public Beta 2 added tethered capture for supported Canon and Sony cameras, background rendering, proxy generation, Fusion remote monitoring and wider access to Studio AI tools. Public Beta 4 concentrated on repair work. It corrected Canon RAW highlights, improved still-image FX controls, exposed Fusion motion paths in the keyframe editor and refined CineFocus output. The final build therefore brings fewer surprises than its version number suggests. That is fine. Production software benefits more from predictable behaviour than another feature attempting to write the porject brief.

The iPad catches up

The clearest final-release addition is DaVinci Resolve for iPad, which now reaches version 21. The tablet edition gains the Photo page with albums, ratings, tags, RAW processing, cloud synchronisation and Resolve’s Color Grading controls. It also receives selected AI tools, expanded keyframing, OGraf and Lottie support, MultiMaster trims and Apple ProRAW decoding. Its feature set still depends on the iPad model and does not match every desktop function. It does, however, move considerably beyond the original Cut and Color configuration.

Pricing and migration

Blackmagic Design turns DaVinci Resolve 21 into a photo app

DaVinci Resolve 21 remains free. DaVinci Resolve Studio costs $295. Projects opened in version 21 cannot return to Resolve 20.3.2. Back up project libraries and individual projects before migration, particularly when shared databases, plug-ins or active deliveries enter the colour pipeline. New tools and innovations should always be tested with representative media and delivery settings before use in production. A missing beta label is useful. It is not quality control.

https://www.blackmagicdesign.com/products/davinciresolve/whatsnew

The post DaVinci Resolve 21 Leaves Beta first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Bend It targets a familiar pain: you want bend, taper, twist, or shear, but you do not want to build a whole 3D scene just to get there. The macro applies those deformation modes to a 2D source, using a mesh-based approach and controls that aim to feel closer to a 3D deformer than a plain 2D warp.

The macro includes bend, taper, twist, and shear modes, and it can process horizontal and vertical deformation in sequence with a user-defined order. It also adds transform controls for both the mesh and the texture, so you can animate deformation and placement without rebuilding the setup.

If you live in Compositing and you keep re-inventing the same rig every month, this sits right in the spot where you normally lose an afternoon.

Mesh density you can animate, not babysit

Bend It exposes mesh subdivision controls that scale with the deformation amount. A minimum subdivision level applies when deformation sits at zero, and the macro ramps toward a maximum as horizontal or vertical deformation approaches its extremes.

The macro also offers a render mode that can show mesh, texture, or both, which helps when you need to diagnose jagged edges or wobble in the texture mapping. The mesh subdivision note comes with a practical warning: shear does not benefit much from higher polygon counts unless you specifically want the wireframe look. About one third into setup tinkering, you will probably start calling this a wrokflow improvement. That is allowed. Just do not say it near a supervisor.

Factors, edges, and a sneaky tiling trick

Bend It includes factor controls that can scale back transformations made in the main controls. Sliding factors down can effectively reset deformation and transforms, which makes for quick animation beats and quick sanity checks. The macro also separates factor locking across mesh and texture if you want independent control.

There is also a practical trick for partial tiling: reduce texture scale and increase mesh scale by the same amount to get an area with repeated texture detail. Edge controls become relevant in that case, because they only make sense when texture scale drops below 1.0. This macro leans into the idea that you should be able to steer both the deformation and the sampling behavior without building a separate rig. If you like compact rigs, you will still need self-control. The settings count is not small.

Lighting and material options, if you insist

Bend It can run with optional direct and ambient lighting, plus basic bump and reflection support. It also includes controls to drive bump, reflection, and specular behavior using a single map, with toggles for inverting individual channels. When you only render the mesh, a diffuse color can be used to set mesh color without enabling lighting.

There is also a direct light widget meant to help visualize light direction. The macro recommends turning it off before final rendering, unless you enjoy explaining UI overlays in finals. The macro uses an orthographic camera. That keeps the tool aligned with 2D results, but it also means depth of field does not function in this setup.

Requirements, quirks, and the stuff that bites at 2 am

Bend It requires Fusion 19.1+, because it uses the Switch node. The Switch tool in DaVinci Resolve 19.1 supports multiple inputs, with a slider that adds up to nine and a Number of Inputs field that can be typed higher.

The macro notes a few known issues and workarounds. The viewer may occasionally show a black frame, but playback or touching settings tends to refresh it, and renders are not described as affected. Motion blur reportedly refused to work on frame zero in one setup, tied to how camera scale checks source ratio on that first frame. A workaround used a Time Speed node with a negative one-frame delay, and a later version changes that approach.

There is also a hard warning: adding an expression to the AA Filter Type setting on a Renderer3D node caused Fusion to crash and could corrupt the comp file. If you take one lesson from this: do not stress-test your production file with experimental expressions five minutes before delivery.

https://www.steakunderwater.com/wesuckless/viewtopic.php?p=57053

The post Fridays for Fusion: Bend It first appeared on DIGITAL PRODUCTION and was written by Manuel Kotulla.

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

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

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

Ten bugs enter the shot, none demand attention

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

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

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

Asset Browser delivery, aka less setup, more anmiation

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

Pricing and the boring part you still need to know

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

Also available through Fab.com.

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

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

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

Stairs that behave like a generator, not a weekend project

Stair Builder is a parametric generator for Maxon Cinema 4D that automates stair construction. A familiar pain point: you drag yourself into the workplace, up the stairs, and then you begin the manual stair modelling, where each revision tends to ripple through steps, landings, and railings like a tiny production disaster. And we know what modern architects like, so this happens often, because modern buildings have more stairs than an MC Escher painting, and enough revisions to let MC look for an easy exit.

The tool focuses on procedural control through C4D’s Attribute Manager, with a preset system intended to store complete setups. Claims call the result “flawless” and “highly accurate” stairs, built without spending hours on steps, railings, and supports. Test that before you bet the house on it!

What it can generate, in plain geometry terms

There are multiple stair typologies: Stair Builder can generate Straight stairs, Two-Flight stairs, L-Stairs, U-Stairs, Concrete stairs, Open-Treads stairs, plus Spiral stairs in round or square variants. Controls extend beyond step count. The workflow includes parameters such as riser height and step depth, with the promise that changing values rebuilds the full geometry instantly. That matters when a client asks for “just a few centimeters less steep” after you already dressed the scene, lit it, and sent previews.

Landing creation gets its own parameters. The tool includes options for flat or stepped transitions, wedge landings in two or three pieces, and extensions on near or far sides. In practical terms, it keeps landings procedural instead of forcing you into manual bridge geometry between flights.

Structural support options include multiple stringer types: Side Straight, Center Profiled, and a Side Stepped option aimed at a folded-plate modern look. If your usual stair method is a cloner stack plus boolean cleanup, this is the part that tries to save you from yourself. Even if that might be too late, if you voluntarily use Bolleans, you poor sod.

Railings, custom parts, and the “do not kill my viewport” promise

A modular railing system is part of the generator. There are main handrails and posts, mid rails, foot rails, balusters, solid panels, and wires as procedural components in the railing layout. Custom asset injection is supported in two directions. You can use your own 3D models for posts and balusters, and you can link closed 2D splines to define custom handrail profiles. The tool also claims optimized viewport performance by using render instances for custom elements and heavy railing runs. That performance angle reads like it was written by someone who has watched a railing explode the Object Manager into a forest of editable clones. On paper, instancing helps keep scenes responsive, especially in large architecture environments where stairs multiply faster than deadlines.

UV and materials: the unglamorous bit that decides if it ships

Stair Builder includes dedicated material slots for structural and railing elements, plus automated UVW coordinate generation and texture rotation for grain alignment. In production, this is the difference between “nice demo render” and “usable across thirty camera angles.” If you routinely apply wood grain across handrails and want it aligned without babysitting, the texture rotation detail matters.

The preset system goes beyond saving numeric settings. It is storing self-contained templates for stairs, railings, or custom assets, including bundled geometries and materials.

One practical reminder: even with tidy UV and preset features, any new generator deserves a test scene before it touches client work. Put it through a few rebuild cycles, slam extreme parameter values into it, and see what breaks before your schedule does.

Pricing and the license model that wants you to read the fine print

Pricing is listed at €25,00.

The activation license allows three activations. The usage examples describe activating on three different workstations across three Cinema 4D releases, or activating three different versions of Cinema 4D on the same workstation, consuming one activation per update cycle such as R22 to R23 to R24.

Once the three activations are used, the plugin must be repurchased. The description frames this as low-cost and “a kind of subscription” that you can manage as you like.

Activation is based on Cinema 4D serials or a subscription license, and the activation process differs from other plugins from the same shop. The tool does not automatically activate after download.

If you work across multiple machines, keep the three-activation cap in mind before you casually burn an activation on a short-lived test install. The time cost of waiting for activation can also matter if you plan to deploy it mid-project.

Requirements: the compatibility floor is clear

The requirements list Maxon Cinema 4D release R25 or greater. Operating system requirements are listed as Apple OSX Snow Leopard or greater, and Microsoft Windows 7 32 or 64 bit or greater. If your studio still keeps an older Cinema 4D around for legacy scenes, this tool draws a hard line at R25+. That can be perfectly reasonable, but it is also the kind of detail that decides whether a plugin becomes a daily driver or a single-seat specialty install.

A small tool with big “stop wasting time” energy

Stairs sit in a weird place in 3D production. They are everywhere, clients notice them, and they waste time far out of proportion to their glamour. A parametric generator that covers stairs, landings, and railings in one object can turn a fiddly modeling task into a predictable asset. But the real value will show up in revision speed.

Do your tests, stress the parameter range, check UVs under real textures, and watch the viewport with heavy rail runs. If it passes, you just got back a chunk of your life that used to be spent nudging stair risers.

https://www.c4dzone.com/en/shop/plug-ins-17/stair-builder-343.htm

The post Stair Builder brings parametric stairs to C4D first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: image-blaster sits between concept and rough layout, using Claude to orchestrate Marble from World Labs and write splat environment files you can move into DCCs and engines.

The headline feature is the splat

image-blaster takes a single reference image and, by default, generates a Gaussian splat of the static environment as an .spz file. This splat is a static environment output, separate from any object meshes or audio it may also generate. It runs as a Claude driven workflow where you put an image into the input folder and ask Claude to blast it while confirming each step.

That .spz environment output targets the fast part of production where you need space, scale, and a place to put cameras. If your team already tracks experiments for gaussian splats, this lands squarely in that bucket, with the advantage that the output arrives as a file on disk rather than a locked viewer.

There is also a time claim of under five minutes to go from image to a fully meshed 3D environment. Treat that as a marketing claim and validate it against your own network, machine, and API limits before you build expectations around it.

Marble, SPZ, and what you actually get

image-blaster lists marble-1.1 as the world generation model it uses for the explorable environment. In practice, that means the environment representation you get from the Marble side is an SPZ splat file. SPZ is Marble’s native splat format, optimised for file size, while PLY is an uncompressed format compatible with more Gaussian splat software packages.

If you plan to wire this into a pipeline, the file format matters more than the demo. SPZ tends to travel well when you stay inside the same ecosystem, and PLY tends to travel well when you want broader compatibility. World Labs also documents a common gotcha: default generated worlds use an OpenCV coordinate system, while many DCC applications use an OpenGL coordinate system, so correcting for that by scaling the Y and Z axes by minus one while keeping X unchanged is necessary. We learned that the hard way.

Splat assets exported by the API use arbitrary model units, not meters, and points to semantics metadata values that can be used for metric scale and ground alignment. That is the kind of detail you want early, because nothing burns time like a “looks fine in the viewer” asset that arrives in the wrong coordinate frame once you ingest it. And, let’S be honest, generated stuff lacks in consistency, and everybody knows. Plan for that!

The workflow is orchestration, not a single model

image-blaster frames itself as a set of skills that orchestrate multiple models. Marble handles the environment generation path that results in the SPZ splat for the static environment. The repository has other models it can involve for cleanup and object generation, but you can treat those as optional if your goal is strictly to generate splats from images.

You run the Claude CLI, provide API keys for World Labs and fal, then feed an image and guide the process via prompts. The repository even includes a development note about removing the app folder from the Claude ignore file if you want Claude to change the React viewer. That means the output can become part of a toolchain rather than a one off experiment. You can keep the same wrapper, swap inputs, and iterate, which is usually what artists actually want when they say “make it usable.”

Where splats meet real tools

image-blaster says you can embed it under the assets of a game engine, DCC software, or a web app. It explicitly names Blender as a target DCC and calls out Three.js for web apps.

image-blaster is open source under the MIT license, but the environment generation step relies on paid APIs. World Labs API billing runs on credits purchased through the World Labs Platform, and credits purchased for the Marble app cannot be used with the API. The API pricing page has a fixed rate of 1.00 USD per 1,250 credits, with a minimum purchase of 6,250 credits or 5.00 USD.

Pipeline advice that saves you from yourself

Splat workflows reward quick iteration and punish sloppy ingestion. Lock down where SPZ files live, how they are versioned, and who converts them, especially if you plan to move between coordinate systems or into other formats. Also, test new tools and innovations before use in production. Verify coordinate orientation, scale, file integrity, and viewer behavior before anyone depends on the output for layout, virtual scouting, or client reviews.

https://github.com/neilsonnn/image-blaster
https://www.worldlabs.ai/
https://docs.worldlabs.ai/marble/export/specs

The post Image Blaster turns images into Splats first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: Conform.Tools sits between offline and finishing, moving timelines and media between Adobe Premiere Pro, Avid Media Composer, DaVinci Resolve, and Autodesk Flame.

What we actually found, minus the wishcasting

The headline feature here is not another file format translator. It is the idea of connected conform as a first-class workflow, with a desktop hub that plugs into finishing instead of living in a folder of one-off scripts.

Plenty of post teams already know how to brute-force a conform. The time sink comes from the repeatable stuff: checks, alignment, searching, and the endless scavenger hunt of tiny fixes that should have been a button. Conform.Tools sells that button collection as Conform Connect, and it keeps pushing the connected part as the point, not a footnote.

Also, yes, the timing feels pointed. If Flame still would push connected conform (Flame-Community: Gentle Encouragement, like Lightwave in 2015!) New tools and innovations should be tested before use in production, especially when they promise to remove steps you currently rely on to catch mistakes.

The desktop hub is in public beta

Conform Connect now has a desktop app as hub -it plugs into DaVinci Resolve 19 and later, and it supports auto-updates after the first install. It is a public beta with feedback welcomed. The release information lists Public Beta version 0.2.10 with the system requirements call out macOS 11 Big Sur or later, Windows 10 or 11 on x64 or ARM64, and Linux on a modern x64 or ARM64 distribution with WebKitGTK. DaVinci Resolve 19 or later is recommended. Resolve Studio is also recommended because some tools rely on the Fusion scripting API, which is gated to Studio licenses by Blackmagic Design. Tools that require Studio are greyed out on the free version.

Install guidance includes setting external scripting to Local inside Resolve preferences, then restarting Resolve so the change takes effect. After that, the desktop app is described as finding Resolve automatically and enabling the toolkit. The conform world has seen plenty of tools that claim they will fix the last mile, then collapse into manual steps the moment the edit gets spicy. So test the cnoform tools on a real-world timeline before you bet a deadline on it.

Pricing that reads like a spreadsheet, in a good way

The pricing page spells out a 14-day free trial for every new account with no credit card required. Pay As You Go is listed at $0 per month with no commitment, with Timeline Exchange priced at $0.05 per shot and i2o transfer priced at $0.25 per GB, plus email support.

Indie is listed at $49 per month for one seat. It includes 2,000 shots per month, 250GB of free i2o transfer per month, seven-day file retention, Conform Connect basic tools, and email support. Pro Team is listed as the most popular plan at $199 per month for three seats. It includes 10,000 shots per month, 2TB of free i2o transfer per month, 30-day file retention, Conform Connect core tools, and priority email support.

Studio Enterprise is listed as contact us for 10 or more seats. It includes unlimited shots, unlimited i2o transfer, 90-day file retention, Conform Connect full suite, air-gapped timeline exchange, dedicated email support, and custom workflow solutions. A yearly toggle advertises a 17 percent savings, and the yearly view shows Indie at $490 per year and Pro Team at $1990 per year.

If that lands, it feels less like a utility and more like a workflow layer for Color Grading and finishing. If it does not, it will join the pile of “helpful” tools that add one more moving part to delivery week. Either way, run a controlled test first, and let your own pipeline decide how much magic you can tolerate.
https://conform.tools/

P.S We found the suite when we were looking for a file size calculator – https://conform.tools/data-calc/ came up, and proved to be useful, as they can even generate Framing Charts! It’s a mixed box of tools alright…..

The post conform.tools’ Connected conform gets a desktop beta first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: Blender uses Blender Cycles for path-traced rendering, and viewport denoising helps lookdev stay interactive while lighting and materials evolve.

The news, minus the confetti

NVIDIA says Blender Cycles will integrate DLSS 4.5 Ray Reconstruction as a new denoiser and ship it with Blender 5.3 in the fall. The goal is a more interactive viewport while keeping a “near-final” look in real time.

DLSS Ray Reconstruction targets ray-traced and path-traced content and replaces traditional hand-tuned denoisers with an AI model that reconstructs pixels in noisy areas where rays were not sampled. It also unifies denoising and Super Resolution into a single model that uses temporal and spatial engine data to rebuild higher fidelity images. Usually, that is for games – you need all the pixels and all the fidelities for veggie-mode in Microsoft Flight Simulator (Don’t Judge, the Dune expansion is great!) Here is a list of all Games that have that, and in that list, you can even spot Redshift, Marmoset and Keyshot. Strange calling those “Games”, but who hasn’t lost to a renderer?

The same announcement says DLSS 4.5 Ray Reconstruction arrives in August for games, and it is also coming to Blender 5.3 in the fall. That timeline matters for anyone planning tool rollouts around seasonal show crunch. Prep first,so you don’t have a bad surprise up ahead.

What changes inside Cycles

Cycles already has an integration path via NVIDIA OptiX. The new piece is DLSS 4.5 Ray Reconstruction as another denoiser option, layered on top of the existing OptiX integration.

If you spend your days in a path-traced viewport, denoising is not a luxury feature. It is the thing that keeps lighting decisions moving. A denoiser that keeps interaction up while pushing the look closer to final could reduce the familiar loop of tweak, wait, squint, tweak again. This sits squarely in the Blender Cycles ecosystem: you still light and shade the same way, you still render the same way, but the viewport becomes less of a tax on iteration.

The longer arc from hacks to shipping builds

Back in February 2026, Blender artist Blake Propst tested a Blender 5.1 build with DLSS on an RTX 3090, with reports of numerous bugs and visual issues. A patch also existed that added an option to use DLSS Ray Reconstruction for viewport denoising in Cycles, and users were encouraged to test Blender 5.1 beta and report issues toward a stable release.

Blender With DLSS!
byu/bbcool2002 inblender

That earlier phase sounded like classic early integration energy: exciting demos, messy edges, lots of caveats, and a very human amount of duct tape. It did prove one thing, though: artists wanted it badly enough to put up with rough builds, because interactive path tracing is still a wrok in progress on most desks. Now the situation shifts from experiments to a shipping target in Blender 5.3.

What DLSS 4.5 Ray Reconstruction claims it does

DLSS 4.5 Ray Reconstruction uses a second generation transformer model. It is improving image quality in ray-traced and path-traced content, and the announcement lists changes such as higher compute capability, more parameters processed while maintaining similar performance to the previous model, better temporal stability, and clearer motion in ray-traced and path-traced scenes. For artists, the practical question is not whether the model sounds clever. The practical question is whether it behaves well under production pressure: animated textures, fast camera moves, thin geometry, alpha heavy foliage, refractive messes, and the kind of lookdev that loves to change one variable per second.

Viewport denoising is where time disappears

A big chunk of render pain is not final frames. It is the time you spend waiting for a viewport to become readable enough to make the next decision. A clean enough image lets you judge lighting ratios, contact shadow behavior, glossy breakup, and whether your material values drift into plastic. A noisy image forces you to wait, or worse, to guess.

The boring parts you still need to know

Pricing is not specified in the sources – propably will be part of drivers or blender itself, so should be free. Read the T&C before downloading, though.

Hardware requirements are not spelt out for Blender beyond the general statement that DLSS Ray Reconstruction works on all GeForce RTX GPUs. The Blender sources mention testing on an RTX 3090 and as part of an RTX focused stack, but they do not provide minimum GPU or driver versions for the Blender 5.3 integration. We’ll see.

https://www.nvidia.com/en-us/geforce/news/computex-2026-nvidia-geforce-rtx-announcements/

The post NVIDIA brings DLSS denoising to Blender 5.3 first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

In this video, we are taking a look at the ongoing effort of the Otoy team to modernise the Cinema 4D Plugin with “quality of life” improvement, as well as newly added features such as the “Material Link”. If you are an Octane C4D user, don’t miss out on this video. I bet you find one or more useful things in there!

CHAPTERS

00:00 Intro
00:32 Tut Overview
01:24 C4D Octane Material Link
03:03 C4D Octane UI Improvements
03:19 C4D Octane Scene / Plugin Settings
03:48 C4D Octane Imager UI
04:12 C4D Octane Rest Position Tag Improvements
04:18 C4D Octane Null Material Improvements
04:40 C4D Octane Nodes Selection Improvements
04:49 C4D Octane Round Edge / Mat Layer ON
05:18 C4D Octane Live Viewer Color Rollout
05:36 C4D Octane Live Viewer Scaling
05:51 C4D Octane Improved Node Previews
06:11 C4D Octane Node Color4 options
06:32 C4D Octane Attribute Node String
07:19 C4D Octane Clamp Edge Displacement
07:47 C4D Octane C4D OCIO support!
09:41 Conclusion
10:23 Patreon Thanks

Download the Tut Scene by becoming a Patreon member. No matter which tier!

VIDEO RELATED LINKS:
Maxon’s Official Website: https://www.maxon.net/
Octane C4D Otoy Official Website: https://render.otoy.com/forum/viewfor…

---

If you’ve ever wondered what happens when a VFX artist spends too much time obsessing over pixels and lighting, well, welcome to my world! You can find all my latest experiments, tutorials, and general nerdy shenanigans here:

Website: silverwing-vfx.de
Patreon: patreon.com/SilverwingVFX (Get scenefiles for all of my tutorial scenes also while supporting me)
Instagram: instagram.com/silverwingvfx (Finished 3D projects and engagement with the community)
YouTube: youtube.com/@SilverwingVFX (Updates and news about my work and what I am up to)

And if you’re into retro gaming and deep-dive nostalgia, check out the big article I wrote for this magazine: my love letter to the legendary Game Boy. Because nothing says “true love” like an 8-bit screen and a battery life that could outlast modern smartphones.

The post C4D Octane: 1.9.x Update Features Video first appeared on DIGITAL PRODUCTION and was written by Raphael Rau.