In this video, next to a lot of other quick tips for a more fluid workflow, we are taking a look at how I handle and correct axis to get my CAD assets into a usable state within Cinema 4D. I am going through a lot of useful features when it comes to the axis tool, as axis placement, axis alignment and much more. If you are working in a fast paced visualization environment this video probably will have the one or the other valuable tip to improve your workflow.

CHAPTERS

00:00 Intro
00:46 CAD Model from GrabCAD
01:30 C4D CAD Import vs MOI Import
03:41 C4D Placing Axis
05:32 C4D Align Axis
07:31 C4D Center / Align Axis for multiple Objects
09:12 C4D Fixing slight inaccuracies
09:54 C4D Different Use-cases and Situations
14:15 C4D Finishing the Model from GrabCAD
16:17 Looking at the shaded model
16:38 Patreon Thanks
17:40 Famous Last Words

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 Using C4D’s Axis Tool in a Product Viz workflow first appeared on DIGITAL PRODUCTION and was written by Raphael Rau.

TL;DR / For those who don’t know the tool: Sneeze sits between spatial services and AR and VR clients. It consumes glTF output from Blender, Maya, Houdini, Revit and Cinema 4D, and forms the engine layer of OMBI at the Metaverse Standards Forum.

A browser engine for rooms

The Metaverse Standards Forum introduces Sneeze on June 15, 2026 as an open metaverse browser engine. RP1 acts as lead architect and maintainer. The engine targets spatial services that appear through location and proximity rather than through a conventional page, tab or app-store download.

The project names Sneeze as the world’s first open metaverse browser engine. That is a marketing claim. Its practical definition is more useful: Sneeze keeps the scene graph, manages network connections, executes service logic and renders a shared spatial scene. A browser or native application supplies the shell around it. The planned release uses the Apache License 2.0 and places the code on GitHub. The final repository URL has not been published, but should be online soon.

The distinction between engine and browser matters. A web browser wraps navigation, settings, updates and user trust around an engine. Sneeze takes the engine role for spatial content. Developers can embed it beside an existing web renderer or use it inside a standalone native spatial browser.

Tabs would get crowded

A normal web browser loads one origin into one page context. Sneeze works with spatial fabrics. A spatial fabric combines mapped content, a coordinate system and related services into an environment such as a city street, university campus, factory floor, airport terminal or game arena.

Every fabric requires a map service. That service supplies geometry, terrain, objects, coordinates and streaming updates. Other services can add presence, communication, commerce, safety alerts, equipment data or location-bound content.

That model gives augmented reality a browser-style discovery mechanism. The engine opens and closes streaming connections as fabrics become relevant. It does not load each environment as a fixed document. Proximity supplies the navigation event.

Rendering gets an adapter

Sneeze routes scene rendering through ANARI, the Khronos rendering abstraction. ANARI describes meshes, materials, lights, cameras and volumes through a common API, then delegates drawing to a renderer underneath. The current architecture uses Filament through an ANARI-compatible wrapper for rastersiation. ANARI keeps that renderer replaceable. The application code above the abstraction does not need a rewrite when the engine swaps the renderer below it.

Tracking and device input pass through OpenXR. Head pose, hand pose and controller state come from the active XR runtime. Sneeze combines that tracking with the user’s position to place the virtual camera in the SOM coordinate space. The render loop reads the SOM as it exists for the current frame. It does not wait for every service writer. Network updates and WASM modules can keep changing the scene while rendering continues, and the next frame picks up the new state. That separation matters across phones, desktops, AR glasses and virtual reality headsets. Hardware changes below the abstraction layers. The scene model and service boundary stay in the engine.

For 3D, VFX and visualisation teams, this vocabulary will reach client meetings long before it settles into production pipelines. We will create the models, materials, animation and environments that spatial browsers present, so names such as SOM, glTF, WebAssembly, ANARI and OpenXR are worth learning before the next briefing becomes another group exercise in confident nodding. Again.

DCCs stop at delivery

Sneeze does not replace content creation tools. It consumes their output. glTF carries 3D models, animation and scenes from the DCC side into the browser engine.

The format can carry mesh geometry, physically based materials, textures, skeletal animation, morph targets and a hierarchy of transforms. Its binary container can package the same delivery data. Sneeze treats that payload as rendered content rather than as an editable authoring scene.

glTF does not carry the live multi-user state, service streaming or change notifications described by the browser architecture. The map service and SOM handle those jobs. The format transports assets; the spatial system handles what changes around them.

KTX supplies GPU-oriented textures. SPIR-V supplies portable shader bytecode. Compiled WASM modules carry service logic. Together they create a delivery boundary between authoring and runtime.

Materials and textures can come from Substance 3D or Quixel Mixer. Models and animation can come from the usual DCCs. The engine sees the files, not the artist’s preferred interface, node graph or collection of mysteriously named final-final files.

That boundary gives existing Blender workflows a direct route into the proposed runtime through glTF export. It does not promise that every shader, modifier, simulation or custom rig behaviour survives the trip.

Game engines need translation

Unity and Unreal Engine projects have a migration path. Assets that convert cleanly to glTF can move across. Engine-specific rendering, physics, UI and networking do not transfer directly. Those systems depend on the original runtime. Custom effects need new shaders or materials for the Sneeze rendering model, while service logic needs the host-function API instead of engine-specific calls.

That makes migration a conversion job rather than an import button. The architecture preserves the distinction between content that crosses the runtime boundary and systems that remain coupled to a game engine.

Server-side adapters provide another route. An existing application can run as a backend service and expose model data through the browser protocol, while Sneeze renders the result on the client. That route trades direct client execution for compatibility with existing server infrastructure.

Open standards, mixed maturity

The engine stack draws from the Khronos Group, the W3C and existing internet standards. ANARI handles rendering abstraction. OpenXR handles XR device interaction. glTF, KTX and SPIR-V cover 3D assets, textures and shader bytecode. WebAssembly runs service logic.

The Metaverse Standards Forum hosts OMBI as an open project for standards organisations, technology companies, developers and researchers. RP1 contributed a working prototype and leads the engine architecture and maintenance.

The project’s open-source plan puts implementation beside standardisation. Code, documentation, test cases, reference services and developer tooling all fit the contribution model. The final code URL remains the missing practical detail at press time.

Academia joins the build

The University of Rochester has launched the Open Metaverse Academic Alliance through its Center for Extended Reality. The alliance brings universities, researchers, educators and professionals into spatial standards work.

Its current focus includes OMBI. Participants can contribute use cases, conduct research, evaluate proposals and work on the open-source engine. The alliance also connects academic work with enterprise partners and student training.

Two AWE sessions, one booth hunt

The Metaverse Standards Forum and RP1 present Sneeze at AWE USA 2026 in Long Beach. The conference runs from June 15 (Yesterday) to June 18. Sean Mann and Neil Trevett will discuss the browser initiative on June 16 at 4:30 PM in Room 101A. A working roundtable follows on June 17 at 1:40 PM in Room 103B. The Forum and Khronos occupy Booth 104. RP1 occupies Booth 928. The first native browser built with Sneeze is due for discussion and demonstration during the event.

The useful boundary

For artists and pipeline teams, the immediate technical point is the runtime boundary. DCCs create assets. glTF, KTX and SPIR-V carry compiled output. WASM carries service logic. The SOM combines live scene state from separate operators.

Sneeze packages those pieces into an embeddable engine rather than a single proprietary application. Its design defines the architecture in substantial detail, while the missing repository blocks code-level inspection before launch.

Open standards case and initiative scope.
https://omb.wiki/standards

Architecture, SOM, WASM, rendering and content pipeline.
https://omb.wiki/sneeze

Original OMBI project page.
metaverse-standards.org/open-metaverse-browser-initative

OMBI launch announcement.
https://metaverse-standards.org/news/blog/introducing-open-metaverse-browser-initiative/

Forum homepage and project context.
metaverse-standards.org

Open Metaverse Academic Alliance.
https://www.rochester.edu/university-research/initiatives/extended-reality-research-and-application-extrra/open-metaverse-academic-alliance-omaa/

Open Metaverse Browser Architecture PDF.
https://cdn.rp1.com/product/Open-Metaverse-Browser-Architecture.pdf

AWE 2026 sessions.
https://www.khronos.org/events/awe-2026

The post Sneeze Brings a Browser Engine to Spatial 3D first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: Filmtext-o-Mat is a local browser tool from Ulf Marquardt Medienproduktion for timed film manuscripts. It exports files for Word, Excel and subtitle workflows, including refinement in DaVinci Resolve.

Timecodes without arithmetic

Writing a film manuscript often means maintaining two documents at once. One contains the actual words. The other exists invisibly inside the writer’s head and tracks where every passage begins, how long it lasts and how badly the timing will break after one late edit. Filmtext-o-Mat 2.7 moves that arithmetic into a small local application. Each manuscript row contains a starting timecode, spoken text, a sequence description and a duration. The user normally enters the duration. The application calculates the starting timecodes.

The calculation begins with a global start value. Filmtext-o-Mat adds the durations of all preceding rows and updates every later entry. Insert an eight-second sequence and all following timecodes move eight seconds forward. Shorten a passage and they move back. This sounds modest because it is modest. It also removes a particularly tedious source of production mistakes.

The first row inherits the global start timecode. That value defaults to 00:00:00 and can be changed, including to broadcast-oriented offsets such as 10:00:00. The total running time updates at the bottom of the manuscript.

Rows without spoken text remain part of the timeline. Openings, atmosphere, visual passages and other silent sections can carry a duration and description while leaving the text field empty. Filmtext-o-Mat gives these rows a separate visual treatment and includes their duration in every later calculation.

The result is a continuous timecode structure without forcing writers to fill silent passages with placeholder prose. Blank narration stops looking like missing data and starts behaving like actual screen time.

Type first, shuffle later

Each manuscript row can move up or down. Writers can insert another row below it or delete it. A separate control appends a row at the end. Text areas grow as their contents expand. Reordering a sequence triggers the same timing logic as changing its duration. The software recalculates later timecodes rather than leaving the user to repair the document manually.

That matters during editorial revisions. A manuscript rarely travels from blank page to approval in one clean direction. … .Which is the kind of obvious that will have you hitting your head on the keyboard, I know.

A writer can also enter timecodes directly. Editing the starting time of a row changes the duration of the preceding row, then updates everything that follows. Filmtext-o-Mat rejects a value that would place the row before its predecessor.

Durations accept seconds, minutes with seconds, or hours with minutes and seconds. An entry can therefore use 8, 1:30 or a complete hour-based value. Displayed timecodes use hours, minutes and seconds.

This relationship works in both directions. Durations generate starting values, while manually entered starting values alter durations. The timeline remains internally consistent whichever method suits the current stage of the job.

The picture stays beside the words

Filmtext-o-Mat places a video player to the left of the manuscript table, or in the top half when you use a portrait screen (See above). A local video file loads directly into the browser and remains on the computer. The application does not upload it. EVERYTHING is local.

The divider between player and manuscript can be dragged to resize the working areas. A double-click restores its default position. The player also retains its fullscreen control.

MP4 files provide the most reliable playback. Browser support still determines which media formats and codecs actually play, so the container name alone cannot rescue an unsupported stream.

A control beside each timecode sends the video to that position. This makes the manuscript navigable in both directions. The picture can create a timing point, and a timing point can relocate the picture.

The final block needs its duration entered manually. Another option is to append a short closing sequence and mark its beginning, which gives the preceding block a calculable endpoint.

Hands on the keyboard

Keyboard shortcuts cover the repetitive actions needed while writing against picture. Control and Enter assigns the current video position to the active row. Alt and Enter toggles playback. Alt with the left or right arrow moves the player backward or forward by five seconds. Outside text fields, the space bar also toggles playback and the arrow keys perform the five-second jumps. Enter confirms values in timecode and duration fields.

One file, local execution

The complete application lives in a single HTML file. Opening that file launches the interface in the computer’s standard browser. It requires neither installation nor an internet connection. The developer has tested it with Google Chrome, Mozilla Firefox and Microsoft Edge.

The self-contained format has several practical consequences. There is no service account, cloud project or server-side media transfer. Moving the application means copying one file. Launching it means opening that file.

It also makes version discipline the user’s responsibility. The manual advises working from a copy and checking that the browser has not opened an older duplicate from the downloads folder.

Filmtext-o-Mat warns when a browser tab contains unsaved changes, but the included manual states that the application does not save projects automatically. The project page separately lists an auto-save function. For production use, the safer interpretation is simple: press Save regularly and retain intermediate project versions.

Save the manuscript, not the movie

The Save command writes the current work to a JSON project file. That file stores the manuscript and can be reopened later through the application. A status dot on the Save control identifies unsaved changes. The project filename follows the film title entered in the interface. For longer productions, the manual recommends retaining intermediate states rather than relying on one continually overwritten prjoect.

Video remains separate from the saved manuscript. Loading a movie gives the browser local playback access, but the project file does not become a media package. This keeps saved files small and avoids duplicating editorial media. It also means reopening a manuscript and reconnecting its corresponding video remain separate actions.

There is no described relinking system, media database or path-management layer. Filmtext-o-Mat saves the writing work. It leaves asset management to the production around it.

Word for people, CSV for tables

Export starts with Microsoft Word. Filmtext-o-Mat creates a DOCX document and opens a dialog for selecting columns. A speaker preset exports timecode and spoken text while omitting silent visual and atmosphere rows. A separate editorial preset exports all four columns.

Users can also choose columns individually, remove empty rows and append the total duration. The resulting document uses A4 portrait layout with 12-point Calibri text.

This is a sensible split. A narrator needs words and timing rather than production notes. An editor or commissioning desk may need the full sequence description and duration structure.

The generated Word file requires no copy-and-paste stage between the working manuscript and a readable handover document. That reduces the opportunity for one version to acquire a correction while another quietly remains wrong.

A second export produces a semicolon-separated CSV file for use in Microsoft Excel. Semicolon-separated lists suit environments where commas already function as decimal separators. CSV also gives production teams a neutral tabular handover. The file can enter scheduling, translation, logging or archive workflows without requiring the recipient to run Filmtext-o-Mat. The browser’s print dialog supplies a further route to paper or PDF. Printing hides the controls and video player. Selecting the browser’s PDF destination creates a manuscript document without the working interface.

SRT as a useful first pass

Filmtext-o-Mat can export SRT subtitles. Every row containing text becomes a subtitle. Its starting point comes from the row timecode, and its endpoint comes from the row duration.

Silent rows do not generate subtitle entries. Their timing still affects everything after them. Long passages split automatically into chunks lasting no more than five seconds. The text divides at word boundaries rather than cutting words in half.

That creates a practical raw subtitles file from the narration manuscript. It does not create finished broadcast captions. The timing remains second-based, and automatic text distribution cannot judge reading speed, shot changes, speaker identity or good linguistic line breaks. The manual directs users toward a dedicated subtitle editor for final adjustment. It specifically names Aegisub and the subtitle tools in DaVinci Resolve. Either can refine the SRT after export.

This boundary is important. Filmtext-o-Mat turns an existing timed manuscript into a starting subtitle file. It does not claim to replace specialist captioning work.

For a documentary workflow, even that first pass can remove duplicate labour. The narration already contains the text. The manuscript already contains broad timing. Exporting both into SRT gives the subtitle stage material it can correct instead of material it must recreate.

Small scope, useful outputs

Filmtext-o-Mat sits early in postproduction, around narration writing, sequence descriptions and editorial timing. It then hands the same data to document, spreadsheet, subtitle and PDF workflows.

The tool also keeps the writer close to the film without turning the browser into another timeline. The embedded player supplies reference picture and navigation. The table remains the main workspace.

That makes Filmtext-o-Mat particularly clear for authored narration, documentaries and factual productions where a manuscript must describe both what viewers hear and what they see.

The author, Ulf Marquardt, has directed and produced documentaries for broadcasters including WDR, ZDF, ARTE and 3sat. His selected filmography includes wildlife, science and environmental productions. The software’s structure follows that manuscript-heavy working context without pretending to cover every possible post pipeline.

Free, with strict modification terms

Filmtext-o-Mat and its manual may be used, copied and shared free of charge. The supplied disclaimer prohibits modifications to the code or accompanying text. This is therefore free software in the everyday price sense, but the published terms do not grant permission to alter or redistribute modified versions.

A voluntary Ko-fi link appears inside the application and manual. The package includes the HTML application and a four-page German manual. German and English downloads are available separately from the project page.

As always, test new tools and workflow changes on disposable material before using them in production.

About: https://www.ulf-marquardt.de/current-projects/filmtext-o-mat/

Source: https://e.pcloud.link/publink/show?code=XZtdcrZRIbUYDTAiOVM8jpKzWt1ApbEAY67

The post Filmtext-o-Mat Tames Timecodes first appeared on DIGITAL PRODUCTION and was written by Nils Calles.

For those who don’t know the tool: NeXus is INSYDIUM’s GPU particle and simulation system. The new edition runs inside Blender, while the established version belongs to the X-Particles and Fused ecosystem for Cinema 4D.

Blender gets the GPU toys

NeXus for Blender has entered beta as a native GPU-accelerated particle and simulation system. It covers particles, liquids, granular materials, smoke, fire, flocking, constraints, spreading effects, meshing, trails and instancing inside Blender. INSYDIUM rebuilt the system for Blender rather than presenting the Cinema 4D edition through a thin compatibility layer. The workflow uses Blender objects and installs through the Blender Extensions platform introduced with Blender 4.3.

The software targets rapid iteration through continuous viewport feedback. Every simulation component in the beta runs on the GPU. Final speed still depends on the graphics hardware, scene complexity and solver settings, so the phrase real time remains a workload description rather than a contractual promise from the laws of physics.

Emit first, negotiate later

The nxEmitter creates particles and transfers properties from point clouds. The current beta update expands the options controlling which properties those point clouds pass into a simulation.

The emission stage connects to a sizeable collection of modifiers. nxAttract pulls particles towards a modifier or target object. nxAvoid pushes them away from specified objects. nxDrag applies aerodynamic resistance, while nxGravity supplies the familiar downward career advice.

nxExplode pushes particles away from a point. nxSplash creates an outward cone force. nxTurbulence introduces noise-driven motion, nxVorticity adds vorticity confinement and nxWind applies directional wind forces.

These tools use layered controls. Artists can combine operations inside a modifier instead of constructing every behaviour through a large node graph. Layers can carry separate values, falloffs and blending controls.

The approach keeps routine motion design accessible while retaining per-effect control. It also lowers the interface tax for artists who want to art-direct particles without turning every adjustment into a small software engineering project.

Fluids cover several arguments

nxFluids handles liquid and granular simulation through PBD, SPH, FLIP and APIC solvers. That gives artists several numerical approaches within the same broad tool rather than tying the entire workflow to one fluid model.

FLIP and APIC cover liquid simulation. PBD and SPH support particle-based fluids and grains. Controls include viscosity, density, surface tension and particle interaction. Different densities can produce different fluid or granular behaviours inside a setup.

nxUpres separates interactive work from final density. Artists can build motion with a lower-resolution emitter, then transfer it to a destination emitter with a larger particle count. This reduces the cost of experimentation before committing to a denser result.

That workflow suits effects where broad motion must settle before final particle counts, meshing and rendering. It does not remove the need to validate the high-resolution result. Increased density can reveal collisions, gaps and surface behaviour that remain hidden in a lighter preview.

Smoke and fire join in

nxExplosiaFX handles smoke and fire. Emitters can derive from objects, splines, vertex maps, shaders and particles. Controls cover particle advection, data-channel mapping and layered treatment of emitters, collisions and forces.

The system requires a modern GPU with at least 4 GB of VRAM and current drivers. That is the minimum, not a comfortable production recommendation for every fluid or volumetric scene. Dense smoke and high particle counts have never shown much respect for minimum specifications.

Motion without node archaeology

The shaping group covers a wide range of common particle operations. nxBlend mixes parameters between neighbouring particles. nxCover distributes particles across target surfaces. nxDirection layers directional control, while nxFollowGeo keeps motion travelling along surfaces or edges.

nxPush separates overlapping particles. nxRotate applies rotational force. nxScale changes geometry scale, particle radius or mass through layered operations. nxSpeed modifies velocity, and nxSpin controls particle rotation.

nxSticky attaches particles to object surfaces. nxWave creates wave motion through noise patterns. These modifiers address jobs that often begin as a simple request and finish as a graph with three frames, two reroutes and one node nobody remembers adding.

Geometry exits the simulation

nxGenerator instances meshes at active particle positions. This turns a simulated particle state into repeated scene geometry for motion graphics, debris, vegetation-style distribution and related effects. nxMesher converts particle emitters into polygon surfaces. Its role becomes particularly important for liquids, where the final image usually needs a coherent surface rather than a visible cloud of points. nxTrail produces particle trails either as a viewport overlay or as curves. The current build fixes a spline-material issue and restores trail thickness when rendering with EEVEE.

The geometry and rendering preview demonstrates this stage of the workflow, while separate official clips cover nxMesher and fluid behaviour. Together they provide a better view of the output path than the initial announcement preview alone.

Blender versions and operating systems

NeXus requires Blender 4.3 or newer. The supported range includes Blender 4.5 LTS, Blender 5 and later releases. Windows and macOS builds are available now. Linux support is coming soon. Windows and Linux require Vulkan 1.3. macOS requires Metal 3.

Online checks remain part of the deal

A customer account is required to access the beta and its licence. Licensing takes place online, so the software needs an active internet connection. The beta also sends anonymous usage statistics. Collection remains permanently enabled during the beta and cannot be disabled. INSYDIUM states that the collected statistics contain no personal information.

Perpetual means this version stays

The beta uses a perpetual licence with a one-off payment. Buyers keep the 2026 version.

All service updates for the 2026.x line are included without extra cost. Future major versions can be upgraded for half of the full price applying at that time. The licence carries neither a subscription nor maintenance fees.

The store lists a full price of £140. The current beta price is £98 excluding VAT, representing a 30 percent reduction. Owners of an eligible Fused licence can receive 50 percent off the full price. This is a paid beta rather than a free public preview. The purchase secures the perpetual 2026 licence while exposing users to software that still carries the beta label and an active repair list. But it shows that INsydium is very confident that they havea well-working tool in their box.

The model may appeal to artists tired of accumulating monthly charges for every specialised tool in the pipeline. It also places the evaluation burden directly on the buyer, since the current product remains under development.

https://insydium.ltd/shop/index.php?route=product/product&product_id=105

• Official NeXus product page: https://insydium.ltd/products/nexus
• Official video channel: https://www.youtube.com/@INSYDIUMLTD/videos

https://insydium.ltd/products/nexus

The post NeXus Beta Lands in Blender first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

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: 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.

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: 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: 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.

For those who don’t know the tool: Massive is a standalone crowd simulation app for building agent scenes, with Arnold rendering, and ties into wider Maya and USD pipelines via the commercial line.

Free, but not aimless

A free edition of Massive Crowd Sim is available for non-commercial use. The core promise is simple: crowd simulation with no limits on agent capabilities, and no limits on the number or complexity of agents in a scene. That makes it a legit learning build, not a teaser that stops when you finally get a crowd moving without looking like a synchronized swimming team. The catch sits where you would expect it: renders are watermarked, and the supported renderers list stays short at the moment, with Arnold plus the built-in Velocity renderer listed as supported.

What you actually get day one

The free edition ships with a complete set of video tutorials and a stack of demo scenes. The demos cover a wide range of setups, including quadrupeds, insects, rigid body dynamics, flying, and shooting. That mix matters, because crowd work rarely stays politely bipedal for long, except Military Propaganda Goosestepping, but the studios doing that don’t need free software and have ALL the budget.

Installation is refreshingly old-school

Setup reads like a throwback in a good way. Download the installer, unzip or untar, and run it. On Windows, you run the installer. On Linux, you drop the bin directory into /usr/local/massive/. The manual can be unzipped wherever you want.

After that, the only required step is to activate the license. Optional environment variables exist, with details documented in the manual. If your pipeline team loves containers, reproducible installs, and predictable paths, this is the rare vendor workflow that does not try to reinvent software deployment. The free edition still expects you to behave like a grown-up about where binaries live, especially on Linux.

Licensing: one machine, one account, bring patience

The first launch triggers a license activation window. You enter the same username and password you use for the Massive 101 forum login. If activation succeeds, the license file lands in the .massive directory in your home directory, then the app starts. After that first activation, the app starts immediately as long as the license remains valid.

There is also a hard limit: only one active license is allowed per account, and a six month delay applies before a new license can be issued. That detail matters for lab setups, shared training workstations, and anyone who reformats their OS the way some people change socks. Not judging, just sayin’.

This is also where a free edition stops being magic and becomes process. If you plan to teach a class or run a studio workshop, design around the one active license rule early, not five minutes before teh first session.

Support: community-first, by design

Because the edition is free and limited to non-commercial use, there is no formal support provided. Instead, the Massive 101 forum exists as the help channel, where users can share tips, ideas, and problem solving.

The forum post also says the team will keep an eye on it, and there might be some input from them. If you are used to commercial support tickets with response time targets, this is not that. If you are used to production artists helping other production artists with practical workarounds, this looks familiar, for better or worse.

Export and pipeline limits you should treat carefully

Massive 101 is almost completely fully functional, with the full simulation toolset and no limits on the number or complexity of agents. It also has specific pipeline restrictions, including that motion, cloth, and hair simulation files save in a Massive 101 file format that cannot be used in Massive Prime, plus that USD and geometry export are disabled.

That incompatibility for Massive 101 and the big one is that there isn’t a row of “Assistant stations” for setup, and only one license for the big Massive to bring it all together.

Those details are important if your goal is anything beyond learning and internal tests. Watermarked renders are an obvious non-starter for client finals, but disabled export can be a more subtle trap if you assume you can “just move it into the rest of the pipeline later”. If your studio pipeline leans on USD interchange, treat this as a training build unless you can independently confirm the exact export behavior in your own testing.

Compatibility and pricing, as stated

Compatibility is Windows 10 and Linux, and free for non-commercial use. For commercial pricing, a perpetual floating license of Massive Prime is at $3500, with rental at $2500 per year, and says Massive Prime includes Massive for Maya.

Where this fits with your current crowd toolbox

If you already live inside the Crowdsim-world, this release sits in a useful niche: training, R and D, seeing if Massive fits your needs, personal skill building, and previs-scale experiments where you want to learn behavior authoring without immediately paying for seats.

For teams already hooked on Maya, the commercial ecosystem includes a Maya-integrated edition, and the broader stack talks about rendering integration and pipeline hooks across supported renderers. That larger ecosystem matters, but the free edition itself focuses on learning and local runs, not studio deployment. Also, Maya, by now, has Golaem built in.

https://www.massivesoftware.com/massive101.html

https://www.massivesoftware.com/massive101/forum/viewtopic.php?t=2

The post Massive Crowd Sim gets a free 101-edition first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

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

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

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

Import, scale, then touch the voxel size slider

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

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

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

Viewport choices and custom instances

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

Pruning, carving, and not paying for invisible cubes

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

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

Static mesh output, plus the part where topology bites back

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

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

Fixed animation options for rigs and deformers

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

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

Assembly animation, because everything must explode nicely now

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

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

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

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

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

Versions, requirements, storefront reality

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

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

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

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

Silhouette 2026 lands with fewer steps between “I need a clean matte” and “shot approved”, without taking the steering wheel away from artists. The release updates multiple ML-driven matting tools that can detect, segment, propagate, and refine, while still keeping the workflow artist-controlled.

The additions cluster around three pain points that never die in production: edge stability over time, tracking that survives real-world footage, and pipeline plumbing that does not explode when you scale beyond a single workstation. Silhouette 2026 touches all three, and it does it in a very node-graph way: new models, new nodes, and more data moving through the graph instead of getting stranded in side files.

AI matting that thinks in objects, not in one mask at a time

The AI toolset gets updates across five ML nodes, with a focus on scalable multi-object workflows. Face ML gets a new model plus new Nose and Neck matte options, a full-face matte option, and deeper integration with ML masking and compositing workflows. Depth Map ML gets a new model aimed at more detail and improved temporal consistency.

Mask ML adds multi-object workflow features, including object list management, foreground and background refinement tools, and per-object Cryptomatte data. Matte Assist ML adds intermediate frame caching, improved propagation performance across long shots, and multi-object Cryptomatte output. Matte Refine ML adds a new Video Matting model for improved temporal consistency along edges, and it preserves Cryptomatte data after refinement.

Be wary: running many ML masking nodes can load multiple custom models onto the GPU and fill VRAM quickly, so the multi-object approach inside a single Mask ML node matters for both speed and sanity.

If you live in the land of shallow depth of field, it is simple: keep your IDs, then soften your edges with the model that holds up over time. The Video Matting model option in Matte Refine ML is a temporal-consistency favourite in the training material.

Head Track ML and the 3D Scene node get real

Silhouette’s 3D Scene node now pushes further into 3D-aware shot work. It is powered by SynthEyes technology, and Silhouette 2026 adds a new workflow centrepiece: Head Track ML.

Head Track ML uses ML to automatically build and track a full 3D head mesh, preserving facial motion and expressions for face-aware effects. The ML model loads onto the user’s graphics card, detects the head, and then Silhouette creates and tracks an aligned and scaled 3D head mesh.

From there, the new Unwrap and Rewrap nodes connect 3D to 2D UV space for roto, paint, and beauty work, and a Render Depth node can generate depth maps from Head Track ML meshes for beauty work or downstream VFX pipelines.

The training walk-through frames the workflow as a practical alternative to the classic “stabilize a patch, paint, reapply motion, repeat until retirement” approach. The point is to unwrap the tracked head into a stable 2D space, do the detail work, then rewrap it back onto the moving performance. It even comes with a candy-wrapper analogy, because every 3D workflow deserves at least one metaphor before it hits the studio floor.

There’s limits: For example, Head Track ML does not detect relative distance between multiple heads, and suggests using an “All render” option in the Render Depth node if a depth map for all heads is still needed.

On the camera side, Refine Solve is designed to let artists improve a camera solve without reprocessing the entire solve. It supports fixing bad frames and smoothing problem areas by deleting erratic or unnecessary 3D features, aiming for more stable solves and faster cleanups.

Tracking upgrades that target the annoying bits of reality

Silhouette 2026 gives love to two tracking tasks that tend to chew time: point tracks that fall apart when anything gets in the way, and repetitive object tracks for faces and license plates.

Point Track ML updates the long-running point tracker workflow with ML assistance aimed at motion blur, occlusions, objects going off-screen, and changing reference patterns. It includes three accuracy settings and Viewer Stabilisation to validate and lock the track. This is not a guaranteed fix, but it increases the chance of success in those failure cases that always show up right before delivery.

Object Tracker detects and creates layers for object classes, including faces and license plates, to reduce setup time, and tracker types support occlusion matte input. In the tutorial flow, it can automatically generate new layers and shapes when new faces enter a shot during a forward track.

This feature that works best when you treat it like a fast first pass – the result may not be 100 per cent perfect, but perfect for fast turnaround work. You don’t get “final shapes”, but points where you can attach additional Tracking data, and modify what needs to be cleaned.

Paint tools that aim for fewer clicks and fewer regrets

Silhouette’s paint system gets new tools and workflow changes aimed at cleanup and beauty work. A new Healing Brush supports cleanup and retouching with expanded colour sampling from any input. Brush controls add blend modes and pressure-sensitive sizes. Blur, Clone, and Drag brushes get more natural and flexible behaviour. Clone workflow updates add continuous mode and auto-grade locking. Resize Paint introduces a resolution-independent workflow that allows working in a lower-resolution session, then rebuilding strokes accurately on higher-resolution media.

Resize Paint is a way to work quickly at low resolution and later rebuild exact stroke replicas at high resolution, which is basically a polite way of saying your workstation fans can stop auditioning for a jet engine while you block in cleanup.

Cryptomatte, data ports, and fewer matte files to babysit

Silhouette 2026 deepens Cryptomatte-centric workflows, and the important bit is that it treats mattes as data that should travel with the graph, not as files that should multiply in folders.

Pipeline changes include passing filtered Cryptomatte data as alpha through nodes via an Matte input, enabling objects and layers to act as matte sources. A new Cryptomatte Mixer node can combine multiple Cryptomatte streams into a single output. ML and AI tools support multi-object outputs with improved viewer-based selection tools to speed up scene isolation and matte management.

Beware the workflow trap: do not build one Mask ML and one Matte Assist ML node per object, because each node loads its own model to the GPU and VRAM fills fast. Instead, multiple objects can live inside a single Mask ML node, and Cryptomatte over the data port can move reference data to Matte Assist ML even when reference keyframes are scattered along the timeline.

For OFX plugin users, there is a limitation: Cryptomatte data cannot simply be routed to an output node and expected to appear directly in the host application, due to how OFX plugins work. The workflow is to export to the file system instead, using an Output Multi node for Cryptomatte-generating nodes.

Export details matter, too. Cryptomatte needs EXR for multi-channel properties and uses only lossless compression, and it warns against lossy formats such as DWAA, DWAB, or PXR24. That is a lot of words to say: keep your IDs clean, keep them in one sequence, and do not turn your matte export into a science project with ten folders named “final_final_3_forreal_v02”. Unless you enjoy that sort of thing. Some people collect stamps, after all.

Performance, stability, and the stuff you notice at 2 a.m.

Silhouette 2026 includes performance and playback improvements through ML node caching for several ML nodes, plus predictive playback via pre-fetching and batched render jobs. Playback controls add optimisation options, including adjustable job queue size, preload frames, and threading settings.

Daily workflow improvements include advanced node search with category, intent, and data-type filtering, a Favourites node, an improved naming system, a context-sensitive HUD, and a Safe Mode troubleshooting workflow to enhance stability in demanding environments.

This is the kind of feature that helps the person who inherits your comp at the worst possible time. If your node tree looks like it was assembled during an earthquake, you still have to deliver, so better search and safer startup modes are not flashy, but deeply production-friendly. Yes, you should still test new tools and innovations before use in production, especially when ML models and GPU caching sit in the critical path.

Pipeline automation and AI assistants, now with actual plumbing

The most pipeline-forward change is a built-in JSON-RPC server and an MCP server. The JSON-RPC server allows studios to drive Silhouette remotely, execute Python code, run script files, and control the application via JSON-RPC.

A Python Package Manager manages third-party Python packages inside a directory in Silhouette and stays isolated from the system Python. This is powerful, and it is also the kind of feature that deserves a boring rollout plan. Build guardrails, keep permissions sane, and do not let the intern’s chatbot become the new show supervisor. The intern already has enough power.

The MCP server allows direct calls from AI assistants, which can inspect projects, build node trees, edit shapes and keyframes, and render frames. “ChatGPT, explain what I did there!” is now a valid question that can be answered. Not truthfully or understandably, because … LLMs, but still.

What to watch to get productive fast

If you want a training rabbit hole, the Silhouette training and tutorial ecosystem lives in the video library and training hub on the BorisFX-site, spanning both quick tips and longer courses on all packages and levels of experience.

Pricing and availability

Silhouette is available as a standalone application and as a plugin, with subscription, upgrade, support, and permanent license options. Subscriptions start at $ 545 per year or $ 103 per month. Silhouette supports macOS, Windows, and Linux. Supported host applications include Adobe After Effects, Adobe Premiere, Foundry Nuke, Blackmagic Resolve and Fusion, and Autodesk Flame.

Customers with an active Silhouette subscription, Boris FX Suite subscription, or an active Silhouette upgrade and support plan receive the 2026.5 release directly as a update.


https://borisfx.com/products/silhouette/

The post Silhouette 2026 gets smarter roto and 3D heads first appeared on DIGITAL PRODUCTION and was written by Bela Beier.