TL;DR: Node Ninja is a free plugin from School of Motion for Maxon Cinema 4D that builds Redshift materials from PBR texture folders.

The promise: stop wiring nodes, start rendering

Node Ninja targets a very specific kind of production friction: the endless, repetitive setup work that happens between downloading a texture set and having a usable Redshift material inside Cinema 4D.

A single PBR texture set can include 6 to 12 maps per material. The manual process is requiring a TextureSampler node per map, wiring each one to the right input on an RS Standard Material, and setting roughness, metalness, and normal maps to the correct color space so they render correctly. Also: the normal map format problem: if a texture set ships with a DirectX normal instead of an OpenGL normal, the mismatch can hide until the render looks wrong.

Node Ninja estimates that the manual approach takes about 4 minutes of node wiring per material and calls itself the one-click alternative. But, let’s be honest: 4 minutes is when you are quick. School of Motion offers Node Ninja as a free download, with no credit card, on Mac and Windows.

Install once, then find it where artists actually look

Installation follows the standard Cinema 4D plugin routine: open Preferences, jump to the Preferences folder, then drop the School of Motion folder into the plugins folder and restart Cinema 4D. After a correct install, Cinema 4D shows a School of Motion entry under Extensions, with Node Ninja and a companion tool called Node Surgeon available from the same menu.

Folder in, material out

Node Ninja works by pointing it at a texture folder, then building a full Redshift node graph based on filenames. It wires maps to expected inputs and sets color spaces. The plugin recognizes common PBR map naming patterns and can auto-handle albedo, roughness, metalness, normal, displacement, AO, emission, opacity, specular, and SSS, with a longer list in the manual. It also claims to composit AO into base color using a color layer and an appropriate blending mode. On normals, it states it can detect DirectX versus OpenGL normal maps and choose the correct type for Redshift, which it describes as using OpenGL normals.

Projection choices, plus an editor for after the fact

At import time, Node Ninja asks whether to use UV projection or world space Triplanar and wires the graph accordingly. If you change your mind later, the included Node Surgeon utility can edit existing materials to switch projection modes, and it can add or remove master controls for scale, offset, and rotation without rebuilding from scratch.

On newer Cinema 4D versions, Node Ninja uses the Redshift UV Context Projection node so tiling, offset, rotation, and pivot adjustments can happen in one place and propagate upstream through the graph.

Bulk import and duplicates, handled like an adult

Node Ninja includes a bulk import mode: point it at a parent folder and it can build one material per subfolder. When it detects a name collision, it offers three options: replace the existing material, duplicate with an auto-increment name, or skip it. That matters when you re-import a library mid-project and you want control over what gets overwritten.

A companion upgrade utility for existing materials

Node Ninja also ships with a second tool aimed at already built materials. The companion utility is included free with Node Ninja and targets existing Redshift materials built with standard PBR textures. There are three things the utility can do without starting over: switch projection modes, add or remove master controls, and upgrade legacy materials to Cinema 4D 2026’s modern UV Context format. It also scans the material first, pre-fills a dialogue to match what is already there, then rebuilds the graph with the requested changes. It CLAIMS it carries texture paths over automatically. There are limits – the utility is designed for standard PBR materials and is not a converter for complex procedural setups.

Cinema 4D versions, older graphs, and the practical bits

Node Ninja supports Cinema 4D 2024.5, 2025, and 2026 on Mac and Windows. If you run an older Cinema 4D version, Node Ninja uses an older style of control setup rather than the newer UV Context Projection workflow, and it can still build unified scale controls through value nodes.

Pricing is simple: free, with no license key and no trial. But nevertheless, new tools and innovations should be tested before use in production, ideally on a copy of a scene, because automation can propagate the same mistake across a whole library at the same speed it saves time.

https://www.schoolofmotion.com/node-ninja

The post Node Ninja builds Redshift materials from folders first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

For those who don’t know the tool: Natsura, the Houdini foliage toolkit lives inside Houdini, can push assets to Unreal Engine workflows, and now leans harder into assemblies, mapping, and export glue.

What shipped in 0.6

Version 0.6.0.0 landed on March 25, 2026, with support for Houdini 20.5 and Houdini 21.0. The release calls out modular effectors, Nanite assemblies, an assembly decorator, a revamped UI, analytics, scan extension, and Houdini 21 support. The update introduces an Assembly workflow aimed at quickly rigging twig and branch libraries and assembling canopies. There is also a set of tools for Unreal Nanite skeletal assembly support, paired with wind authoring tools. Assembly-related nodes are flagged as experimental in the release notes, though. Be careful.

On the shaping side, the release adds a modular effector system like a bolt on simulation modifiers with no VEX required. Effectors are an extendable stack, and the base effector node supports writing VEX to extend the simulation and respond to geometry and inputs.

Assemblies, decorators, and Unreal export

The release adds new nodes for an assembly pipeline, including an assembly resource node for mesh library import and auto rigging, an assembly decoration node for canopy decoration that can pick modules based on traits and transform instance hierarchies with rigid rotations, and a classify node for trait-based module classification.

Export to Unreal related workflows gets multiple mentions. The export node for Unreal Nanite assembly lists updates including material support, skeletal and static assembly, fixed instance naming, and removal of a transform on points that broke instancing. There is also a LOP node for USD workflows that creates a Nanite assembly for SOP based creation.

Wind support is expanded through new nodes for wind initialisation and validation, wind class assignment for Unreal, a wind preview visualisation tool that is functional but not accurate or meant to look good, and a node that exports UE5 DynamicWindSkeletalData as JSON. If your environment team already has a wind data convention, this is the part to validate early, especially around naming, material binding, and what your in-engine tooling expects.

Effectors, guides, and growth controls

Several new effectors are listed: deflection, magnet attraction, gravitropism, gravity, and noise based growth perturbation. The grow node line gets a long set of updates in this release, including a new spiral parameter with absolute and relative modes, integration with the effector stack, and an updated decorator stack format to match the effector stack.

One practical change is the way mapping and prim construction are described. Map prim construction is deferred to grow, which is described as reducing node count and compile time. There is also an instant colour preview mentioned, plus options for skeleton swapping and custom draw modules. Growth workflows appear to be treated as a family of versions, with backwards compatibility restored across multiple grow versions and various mapping and parameter warning cleanups.

Rig simplification and reskinning

Rig simplification tooling shows up both as a new simplify rig node and as updates to a simplify rig reskin path, as well as multi stem tree support, chaining of simplify nodes, and added carve method and max joints count. If your pipeline needs a predictable joint budget for game ready trees, this is where you will want to spend time.

Analytics and privacy details

Analytics is “opt-in” and disabled by default, with no data collected without explicit user consent. If you work in an environment with strict compliance rules, the opt in default and EU cloud note are helpful details, but you still need to run your own review. Make sure your team knows what is allowed, and that tool telemetry decisions match your facility policy.

The notes also state that 0.7 will be a breaking release, and this 0.6 release includes precursor work such as a standardised mapping architecture, groundwork for decorator cook trigger decoupling, and a foundation for mappable decorator parameters. Read that as a warning to keep a rollback plan, and to budget time for update testing before you touch active porudction setups.

Compatibility notes for Houdini artists

Houdini 21 support is obvious, including mention of an APEX graph schema enforcement fix. The release also claims continued full Houdini 20.5 support, plus compatibility work around Qt bindings.

In practice, this release spans a lot of surface area: SOP level nodes, UI panels, export to Unreal, USD workflow hooks, analytics, and a mapping engine refactor. That is a lot of moving parts for a minor release number, even if the changelog is transparent about what is experimental. Treat the upgrade like you would any node library update: keep a copy of old scenes, validate the graphs, and test exports end to end before shipping anything client facing.

https://www.natsura.com/

The post Natsura 0.6 adds effectors and Nanite export for Houdini Foliage first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

dy Install Libs is built to make installing libraries smooth and simple, with the stated goal of avoiding manual edits and broken installs. It ships as a shelf toolset for Houdini, aimed at the everyday stuff artists actually do: bring in a library, make sure it loads, and move on with their lives. The headline feature in v1.3 is Library Manager, a custom UI tool to download, install, enable, and disable local libraries. Version v1.3 is dated March 24, 2026, with a follow up v1.3.1 dated March 26, 2026.

The part you came for: Library Manager

Library Manager adds a single interface for discovering, installing, and managing open-source and commercial Houdini libraries. That matters because library installs rarely fail in exciting ways. They fail in slow, petty ways, like a missing file, a wrong path, or a package file that loads everywhere except the one machine that counts.

This release frames Library Manager as an evolution and combination of the earlier toolkit tools. The idea is simple: fewer trips into the filesystem, fewer chances to fat finger a package entry, and more time spent actually using the tools you installed.

There is also an explicit caveat: it may not work for installing render engines, since they typically require a custom JSON package file to set up environment variables and paths. In other words, the tool targets the library side of life, while heavyweight integrations can still demand a hand-tuned setup.

What dy Install Libs does around the manager

The toolkit includes several functions that cover the library lifecycle, from bringing in data to keeping package files aligned with where the library lives. Library from JSON imports a downloaded library using its JSON file and automatically copies and updates the package file in your library folder. This is the one for when a library arrives with its own packaging info and you want it to just land cleanly.

Install Library generates a new JSON package from scratch tied to your library folder. That means you can start from nothing and still end up with a package file that points where it should. Library from GitHub clones and installs libraries straight from a GitHub URL, which is handy when the library lives as a repo instead of a zip. It also supports downloading repository releases. That support is listed in v1.1 dated August 5, 2025.

Create Library builds a library scaffold with templates and auto-generates the package file, which aims at standardizing how a library starts its life on disk. Restart Houdini to reload everything with one click, when you want the tool to do the classic on-and-off ritual for you.

GitHub reality: releases, missing packages, and relative paths

Git based libraries come with their own quirks. The release notes for v1.1 include a fix for cases where a repo does not have a package file, replacing an older path JSON variable with hpath. It also adds support for relative paths using the $HOUDINI_PACKAGE_PATH variable in installed package files.

That combo matters because repos vary wildly in structure. Some ship a tidy package file. Some ship nothing but hope. Tooling that acknowledges those differences tends to be more usable in real production setups, where you do not control every library you need to install.

Small fix, big impact

v1.3.1 lists support for the enable key from package files when it appears as a string, while it should be a boolean. It also lists a URL key fix for when a library from a database is installed manually as a standalone library, along with small fixes and improvements.

Pricing and the practical bit

The tool is free to download, with a Gumroad listing shown as $0+. Pricing beyond that is pay what you tink it is worth.

Pipeline advice that still counts

Even if Library Manager makes installs feel effortless, new tools and innovations should be tested before use in porudction. Try it in a clean preferences setup first, confirm your package behavior matches expectations, and then let it anywhere near a show.

https://cdordelly.gumroad.com/l/dy_install_libs

The post dy Install Libs adds Library Manager to Houdini first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Blender To Unreal Live Link is built around a simple promise: push models, materials, and textures from Blender into Unreal Engine without bouncing through a traditional export and reimport loop. The workflow centers on a Blender add-on and Unreal-side Python scripts that sit inside your project so the handoff happens from inside your normal working tools. The add-on supports one-click sending, and it also offers an auto-sync mode for iterative work.

Milad Kambari (Artstation) sells the add-on for $18 on Superhive.

Getting connected without guessing

After installing the Unreal plugin and the Blender add-on, the two applications connect through a Start Live Link action on each side. In Blender, the workflow uses a Start Live Link button. In Unreal, the workflow uses a Blender Live Link menu with its own Start Live Link action.

The first connection can take longer than later runs because the network communication between the applications establishes itself for the first time. A connected status indicates the link is established. If you want to confirm the setup path executes correctly, the workflow suggests checking the log and watching for errors shown in red. If you do not see red errors, that indicates the path was set up correctly, and the instruction is to keep the plugin and scripts in the right place and stay patient while the connection finishes.

Send selected, send full scene, and why one is a trap

Once connected, the basic transfer flow centres on selecting assets in Blender and sending them across. The add-on offers two transfer options: Send Full Scene and Send Selected. Send Full Scene is positioned for smaller to medium scenes, and Send Selected is positioned for larger scenes where you only push what you need.

The usage guidance recommends not leaning too heavily on Send Full Scene because real scenes can be heavy, with a large number of objects. The suggested working method is to proceed with Send Selected so you keep control of what moves over, and to transfer heavier scenes piece by piece. The stated goal is better scene management while avoiding the need for extensive hardware resources.

The workflow description also demonstrates sending multiple objects at once using Send Selected, where selecting multiple objects and running the send results in both arriving in Unreal.

Materials, textures, and the two-lane road

Material transfer is included alongside geometry transfer. The tool is described as able to send materials along with textures, including transferring a model together with its texture. The product listing also states that simple physically based materials transfer automatically with textures for base color, normal, roughness, and metallic.

When materials get more complex, the workflow shifts to a different option. The add-on includes a Bake and Send Selected mode intended for complex materials that need baking before they can be sent. The listing describes complex shader setups using nodes such as the Mix node as examples that can require this path. In this mode, materials are baked into clean textures for transfer, and the workflow is described as non-destructive, restoring original materials after the send. The tool detects whether a model has UV maps. If UV maps exist, it does not alter them and uses them for baking. If a model does not have UV maps, it can generate UV maps as needed for baking.

Live sync, but with a leash

Live sync mode sends changes automatically, but the workflow has a specific rhythm. For edit mode changes, the flow relies on exiting edit mode. After you make an edit, you exit edit mode and return to object mode so the edit becomes visible in Unreal.

Live sync is also framed as “something to use carefully”. The developer does not recommend using it extensively because it can require hardware resoruces due to the different graphical structures of the two applications.

Hierarchies, pivots, and scale sanity

On the scene-structure side, the listing describes parent and child support. Selecting a parent object can include its mesh children automatically, which matters when you are working with grouped meshes or hierarchical scene organisation.

It also preserves pivots. Object origins from Blender are preserved in Unreal, so the pivot behaviour you author in Blender carries through after transfer. Scale handling is called out too. The listing describes a 1 to 1 scale relationship between Blender and Unreal, aimed at avoiding the classic scale mismatch workflow pain. Transforms are part of the transfer. Location, rotation, and scale are sent and applied in Unreal.

What is included and what it needs

The package includes a Blender add-on file and Unreal Python scripts named blender_livelink_addon.py, livelink_unreal.py, and init_unreal.py.

System requirements list Blender 5.0 or higher and Unreal Engine 5.5 or higher, plus Windows 10 or 11, with the condition that both applications must run on the same machine.

Pricing is listed as $18.

Practical takeaways for production artists

If your daily loop includes moving assets from Blender into Unreal for lookdev, lighting, layout, or realtime checks, this tool focuses on reducing the friction in that handoff. It provides Send Selected for controlled transfers, Send Full Scene for smaller setups, and Bake and Send Selected for complex material cases that need baking. It also includes live sync for iterative updates, with workflow notes about exiting edit mode so edits propagate.

As with any new pipeline tool, test it in your own environment before you rely on it for production.

https://superhivemarket.com/products/blender-to-unreal-live-link

The post Real-time Blender to Unreal Live Link first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

If your modeling flow depends on lining up a mesh to photos, you already know the usual pain points inside Autodesk Maya. You set up a camera, attach a reference image, tweak focal length and framing, then bounce across panels and settings while your brain tries not to forget what the likeness looked like two clicks ago. Handy RefTool aims straight at that friction by collecting the controls for reference matching into a single interface. The practical target is portrait modelling, but the same camera to image alignment problem shows up everywhere you match a 3D model to reference images. That includes creature design and hard surface work when you want the model to sit cleanly against a specific plate or photo set.

Classic mode, fewer context switches

RefTool includes a Classic mode that sets up reference cameras by automatically creating a camera in a scene and assigning a reference image to it. From there, the workflow focuses on fast iteration. You can adjust camera settings via slider controls, rotate around the model, zoom in for alignment checks, and scrub the opacity of the reference image to see how closely the sculpt lines up.

That opacity scrubbing matters more than it sounds. It turns the usual on-off flipping of an image plane into a continuous check, so you can keep your eye on silhouette, landmarks, and proportions without turning the viewport into a strobe light.

Once you have a camera setup you like, RefTool can export it as a JSON file, allowing you to reuse it in future projects. That reuse angle fits neatly with production reality, where you do not want to rebuild the same camera matching scaffolding every time a new head variant or costume pass drops into the scene.

RefBoard mode turns cameras into a wall of thumbnails

When you have multiple reference views, the real time sink is not creating them. It is switching between them in a way that keeps you oriented. RefTool includes a RefBoard mode that lets you arrange camera views like an image board and switch between them by clicking on thumbnails. That thumbnail switching also plays nicely with the way artists actually work on likeness. You rarely stay married to one image. You bounce between angles, you cross-check, you sanity test, and you keep moving. A board of camera views makes that bounce less disruptive than hunting through the outliner or viewport menus for the right camrea at the wrong moment.

Install notes, plus a very specific graphics requirement

There are two tracks here, and the install experience differs. For the free RefTool v2.1, installation runs through the Script Editor inside Autodesk Maya. You open the Script Editor, load the RefTool_v2.0.py script, then either execute it immediately or save it to a shelf for a one-click launch later. The same listing also includes free scripts labeled RefTool v2.1.1, including RefTool v2.1.1.py and RefTool_V2.1.py.

For the full RefTool v3.0, the install path starts with unpacking an archive. You then open Autodesk Maya, switch the Script Editor to the Python tab, drag and drop a maya_installer.py file into the editor, and click Save. A file dialog prompts you to select the RefToolV_X.X folder that contains the source files. After that, the tool icon appears on the currently active shelf.

One operational detail comes with a big warning label. Each time the tool launches, it runs directly from the folder selected during installation. If you move, rename, or delete that RefToolV_X.X folder after installation, the tool stops working. Both the free and full installs include the same requirement: Viewport 2.0 inside Autodesk Maya needs to be set to DirectX 11.

Versions and pricing

The version split is straightforward on paper. RefTool v2.1 is free and is described as having the core functionality. RefTool v3.0 redesigns the interface and adds extra functionality. The published price for version 3.0 is USD $14.48.

Where this fits in real work

The strongest signal here is not a single feature, it is the focus on keeping the artist in the flow. Reference matching is foundational for portrait work, but it is also a repeated micro-task across creature blockouts, prop modeling, and any job where a specific camera-to-image relationship matters. RefTool targets those repeated touches by putting the camera adjustments and reference image controls in one place.

The JSON export for camera setups adds a pipeline-friendly hook. Reusable setups can reduce churn when a project revisits the same asset type across multiple shots or deliverables, or when a team wants consistent camera matching conventions for a specific modeling task. As always, new tools and workflow tweaks should be tested before you let them anywhere near a production deadline, especially when the tool depends on specific viewport and graphics settings.

https://www.artstation.com/marketplace/p/PBWgY/maya-reftool-the-ultimate-camera-reference-manager-new-version

The post Handy RefTool 3.0 speeds Maya ref matching first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

The problem NanoGS tackles

3D Gaussian splatting can look like magic right up until it starts behaving like a tax audit. Big captures mean millions of splats. Millions of splats mean constant sorting work, a lot of memory pressure, and a very real risk that the renderer spends time drawing things the camera never sees. NanoGS targets that exact pain: rendering large-scale Gaussian splatting files in real time, while handling video memory pressure, sorting huge splat counts efficiently, and drawing only what the screen needs.

The approach focuses on a set of optimisation techniques: Nanite-style LOD clusters, screen-space error LOD selection, splat compaction, a global accumulator, and GPU radix sort. The headline promise is straightforward: large-scale Gaussian splatting scenes should render efficiently, with an emphasis on keeping memory usage low. That is a marketing claim.

Supported engine versions and what you actually install

NanoGS lists support for Unreal Engine versions UE5.6 and UE5.7. The workflow stays inside the familiar plugin lane. You download the plugin from the releases page, place it into your project’s Plugins folder, then import a PLY file using the plugin import button. That import creates a Gaussian Splat Asset, which you can drag directly into a level for rendering.

There is also an asset action to enable or disable Nanite if needed. It is an unusual sentence to write about splats, but that is the point: the tool is trying to make splats behave like a native citizen in the realtime world.

The controls that decide whether it feels stable

The plugin exposes settings grouped by intent. They map cleanly to the trade-offs most realtime teams already juggle: quality, performance, and final look. On the quality side, SH Order adjusts spherical harmonics quality. On the performance side, Sort Every Nth Frame changes how often splats get sorted. Enable Frustum Culling turns frustum culling on or off. LOD Error Threshold sets how sensitive LOD cluster switching should be. On the rendering side, Opacity Scale adjusts splat opacity, and Splat Scale adjusts splat size.

These are not vanity sliders. Sorting frequency can be the difference between a stable camera move and a shimmering mess. Culling can be the difference between a scene that fits and a scene that explodes memory. LOD sensitivity can be the difference between crisp detail and visible popping. And opacity and scale are the levers that decide whether the splats read as a coherent surface or as a cloud of regret.

About one third into your first test session, you will probably notice the same thing most teams do: the scene can look fine at rest, then fall apart during motion if sorting gets too infrequent. That is when you stop guessing and start dialing.

Debug commands that make problems obvious

NanoGS includes console commands designed for inspection and stress testing. gs.ShowClusterBounds 1 enables a Nanite cluster preview, and setting it to 0 disables that preview. gs.DebugForceLODLevel can force rendering at a specific LOD cluster level for debugging, with values like 1, 2, 3, 4 and so on.

Then there is the one that will get used the most in anger: gs.MaxRenderBudget. It limits the maximum number of visible splats after culling to save memory. The default is no limit, using 0. You can set a maximum cap such as 3,000,000. When the cap is active, the culling starts from splats far from the camera.

If you are trying to ship anything on fixed hardware budgets, this kind of explicit cap is refreshing. It makes the failure mode predictable. It also makes it easier to have honest conversations with art and production, because the tool draws a hard line instead of pretending everything will fit if you just believe harder.

Best practice: do not feed it one giant splat brick

NanoGS calls out a best practice that will sound familiar to anyone who has ever fought streaming, culling, or draw lists. A single big chunk of gaussian splatting file does not help performance optimization. Splats outside the camera view cannot be culled effectively. And if everything stays in one chunk, all splats stay engaged in sorting all the time.

The recommended format is to slice a large splat file into smaller pieces. Examples given include individual props for cinematic scenes or tiles for geo-spatial data. The repository includes a simple tile slicer written in Python to support that workflow.

Proof of concept, not a miracle

NanoGS is described as a proof of concept, with a clear warning not to expect perfect results. Issues can be reported on the project page. That framing matters for production teams because it sets the correct expectation: you are evaluating a technique and an implementation, not adopting a finished commercial renderer. The good news is that the tool is built to be tested, with the kind of switches and debug views that make evaluation less mystical.

New tools and innovations should always be tested before use in production, especially when they touch core rendering paths and memory budgets.

Release, license, and what it costs

NanoGS is released under the MIT license.

The repository lists v1.0.1 as the latest release, dated March 20, 2026.

The plugin is free.

https://github.com/TimChen1383/NanoGaussianSplatting

The post NanoGaussianSplats for UE5 first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

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

The release vibe: refine, then refine again

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

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

Raycast: a shader node that likes to ask questions

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

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

Rendering: faster compiles, leaner memory, quicker frames

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

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

Animation and rigging: the biggest speed win in the room

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

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

Compositing and editorial: nodes that earn their keep

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

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

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

Modeling and sculpt: a pile of small wins

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

Grease Pencil: holes, at last

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

Geometry Nodes: more rig friendly, more volume friendly

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

UI, file I O, and pipeline glue

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

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

Availability and licensing

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

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

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

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

For those who don’t know the tool: Foundry develops tools including Nuke and AI features such as CopyCat. Griptape is an AI orchestration platform with a Python framework and node interface, aimed at integrating multiple AI models into production pipelines.

A strategic buy, not a feature drop

Foundry has confirmed the completion of its acquisition of Griptape, an enterprise AI orchestration platform founded in 2023 in Seattle. According to Foundry, the acquisition adds orchestration capabilities to its existing AI-powered features, which began in 2021 with the release of CopyCat inside Nuke. CopyCat introduced machine learning training directly within the compositing environment. The Griptape acquisition is positioned as the next step in that strategy. Foundry states that the deal accelerates its AI roadmap by enabling the orchestration of multiple AI models and agents within professional workflows that integrate with its existing creative toolsets. The company describes this as critical as studios move from AI experimentation to routine production use.

No financial details of the acquisition were disclosed.

What Griptape is

Griptape describes itself as an “enterprise-grade AI orchestration platform”. It was founded in 2023 by former Amazon Web Services veterans and offers a dual-layer architecture. The first layer is an open-source Python framework. This provides programmatic control over AI models and agents. The second layer is a node-based visual interface designed for artist-facing workflows.

According to Griptape, the platform enables controlled access to open-source and commercial AI models within a secure and traceable framework. It is designed to balance model flexibility with the security requirements of large-scale production environments. The company states that Griptape is already in use at several leading production studios. Specific studio names were not disclosed.

Orchestration, not generation

Foundry’s announcement does NOT mention generative features. Instead, it focuses on orchestration. In practical terms, this means managing how multiple AI models and software agents are invoked, connected and governed inside a production pipeline.

Foundry highlights the need for better control over AI models as studios shift towards daily production use. It positions Griptape as a framework that allows access to both open-source and commercial AI systems while maintaining security and traceability. Traceability in this context refers to tracking which models, prompts or agents were used in a workflow. This is increasingly relevant for studios that must document provenance and comply with contractual or regulatory requirements.

Programmable agents in production

A central point in the announcement is Griptape’s support for secure, programmable agents. Agents in this context are software components that can execute defined tasks using AI models and other tools. According to Foundry, these agents can operate within Griptape and across the wider pipeline.

The company distinguishes this from simple conversational interfaces. The implication is that Griptape is not positioned as a chat-based assistant but as a programmable layer. This distinction matters for production environments where repeatability, logging and integration with asset management systems are required.

Context within Foundry’s portfolio

CopyCat marked the first visible step in that direction inside Nuke. Griptape shifts the focus to pipeline architecture rather than isolated ML nodes. From a technical perspective, the combination of a Python framework and a node-based interface aligns with established DCC and pipeline patterns. Python remains the dominant scripting language across VFX facilities. However, no specific integration APIs, SDK updates or version dependencies have been detailed, as well as integrations with Katana, Mari, or even Flix. It is also not clear how authentication, model hosting or cloud dependencies will be managed within Foundry’s subscription-only ecosystem.

What is not yet stated

Several practical questions remain unanswered, for example, no pricing information for Griptape under Foundry ownership has been published yet. It is not specified whether Griptape will be bundled with existing Foundry licences, offered as a separate subscription, or integrated into enterprise agreements. These omissions are not unusual at the acquisition stage. But they will matter to pipeline TDs and production engineers planning near-term infrastructure changes.

At present, the confirmed facts are limited to the acquisition itself, Griptape’s architectural description, and Foundry’s intent to integrate it with Nuke and broader pipelines. As always, new tools and innovations should be tested thoroughly before use in production environments.

https://www.griptape.ai/

Foundry.com

The post Foundry buys Griptape to “orchestrate AI” first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

3DCoat 2025.15 introduces a new Lofted Surface option within its Plane tool. The feature expands on-plane brush control, allowing for more detailed adjustments when sculpting or aligning geometry on surfaces. The update also refines plane picking mechanics: users can now hold the right mouse button to move the plane’s central point across a surface while maintaining its normal direction, or hold Ctrl to shift the plane along that normal.

AppLink and Python updates

The Blender Applink now officially supports versions 4.3 through 5.0, broadening compatibility with recent Blender releases. 3DCoat’s scripting system adds support for Python 3.11.9, improving script execution and language stability. AppLink integration now allows the execution of a Python script during import: placing an import.py next to import.txt triggers automatic script execution. The update also removes obsolete .py files in custom rooms to prevent interface errors after rolling back to earlier builds.

Split, Snap, and Offset

A new Split by Curve option enables complex surface cuts, improving precision in hard-surface workflows. The Smart Retopo tool in the Retopo and Modeling workspaces now snaps to sculpted surfaces only when creating new meshes, reducing unwanted interactions with existing geometry. The Smart Hybrid function gains a new Offset option and refined Quad Mesh generation for both patch and triangle-based surfaces.

Workflow and performance fixes

Multiple long-standing issues have been addressed. Under macOS, the Text Tool no longer crashes, supports Unicode, and correctly displays the text cursor. Random filled cubes appearing during airbrush sculpting are resolved, as are conflicts between navigation gizmos and tweak tools. The Transform palette now preserves visual object size during resampling, preventing scale discrepancies. A fix in the Retopo workspace ensures that pressing Esc clears path selections as expected.

Quality-of-life improvements

Users can now copy complete colour data, not just single channels, via Copy Channels. Fullscreen mode hides the tool parameters panel to declutter the interface. 3DCoat adds Lychee Slicer as an external 3D-printing option and introduces an internal check before creating low-poly meshes if the target Retopo group is invisible.

Stability first

According to the changelog, this release includes “multiple other fixes and performance improvements,” including corrections for Live Boolean artefacts. As always, artists should test the update in production before deployment, especially when integrating custom scripts or AppLink workflows.

The post Lofted Surfaces and Retopo in 3DCoat 2025.15 first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Transitioning assets from Blender to Unreal Engine 5 can often feel like trying to fit a square peg into a round hole. Enter Scott Rafferty’s Python script, BlenderCollection2Empty, designed to smooth out these workflow wrinkles.

Automated Collection Conversion

Traditionally, converting Blender collections into empties required manual effort, akin to herding cats. BlenderCollection2Empty automates this process: it parents all objects within a Blender collection to a newly generated empty. This ensures that complete hierarchies, child objects, and naming conventions are preserved, turning a tedious task into a one-click solution.

Enhanced Usability

Recognizing that convenience is king, Rafferty has updated BlenderCollection2Empty by integrating it into Blender’s sidebar. This enhancement makes the conversion process even more accessible, allowing artists to execute conversions without navigating through multiple menus.

Availability and Further Information

BlenderCollection2Empty is available for download on GitHub. For those interested in exploring more of Scott Rafferty’s projects, including MaterialVault, additional information can be found through these links.

The post Simplify Your Blender to Unreal Workflow first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

BlenderCraft isn’t just an add-on; it’s a block-based playground for Blender enthusiasts. Designed for crafting Minecraft-style environments, it equips artists with procedural generation tools and over 300 Minecraft blocks ready to use at the click of a button. Available for just $8 on BlenderMarket, it’s as budget-friendly as it is feature-packed.

Everything BlenderCraft Offers
BlenderCraft lets you procedurally generate Minecraft-style terrains directly inside Blender. Over 300 prebuilt Minecraft blocks are included, ready to drop into your scenes with minimal setup. The add-on features a seamless and visually accurate Minecraft-style user interface, ensuring that block placement, editing, and management feel intuitive.

Fully Customizable Inventory
BlenderCraft introduces a fully draggable inventory, which can be repositioned anywhere in Blender or even on a second monitor. This enhances workflow efficiency and makes it easier for artists to focus on creative exploration without clutter.

Python and PyQt Required
For all its ease of use, BlenderCraft does require some backend preparation. Users need to have Python and PyQt installed to run the add-on smoothly. This prerequisite ensures that the interface and features perform seamlessly but might require a bit of setup for non-technical users.

The developers promise ongoing updates, adding new features and content to keep BlenderCraft at the cutting edge of Minecraft-style design.

Blender Integration
Built to integrate with Blender’s existing tools, BlenderCraft supports automatic UV mapping, works with modifiers, and allows for procedural flexibility. The streamlined interface ensures that users can focus on building while the technical details are handled in the background.

For just $8, BlenderCraft is a low-risk, high-reward addition to your Blender setup. It’s voxel art made smarter, faster, and way more fun.

The post BlenderCraft: Bringing Minecraft-Style Worlds to Blender first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

The newly released Howler 2025 brings a range of features targeted at professional users working in digital content creation. Developed by the Project Dogwaffle team, Howler is a digital painting software known for its versatility in animation, FX generation, and natural media simulations. The 2025 edition extends the software’s functionality by integrating AI-powered tools aimed at speeding up workflows, especially in animation and VFX tasks. Artists can now take advantage of machine learning to automate certain processes, though it is advised to verify results before using them in production.

The software introduces AI-driven Rotoscoping and Animation Prediction, allowing users to automate keyframing and frame interpolation for smoother transitions between frames. This feature leverages deep learning to predict motion paths based on existing frames. You can now skip the tedious manual interpolation of in-between frames, but as always, it’s a good idea to review the automated results for any corrections.

Howler 2025 also comes with GPU-accelerated FX rendering, improving the speed of rendering tasks significantly. This is particularly useful for users working with high-resolution media, as GPU acceleration helps to reduce bottlenecks during rendering, especially when generating complex effects like particle simulations, weather effects, and motion blur. GPU support extends to the Particle Modeler and Cloud Generators, offering real-time previews of these FX.

One of the new tools is the Image Stabilizer, which aids in reducing shakiness in animation sequences, making it a go-to feature for post-production professionals handling footage with camera shake. This stabilizer is particularly helpful for those dealing with live-action elements combined with CGI. You can apply these stabilizations globally or locally, depending on the sequence.

There’s also an expansion of the Brush Engine, which now includes dynamic brushes powered by AI that adjust to the user’s workflow. These brushes simulate various natural media effects in real-time, enhancing the user’s ability to create complex textures and paint effects with minimal manual adjustment. Howler has also introduced new 3D Paint Capabilities, enabling artists to paint directly onto 3D models and surfaces, offering more versatility in asset creation for 3D pipelines.

With regard to file management, Howler 2025 introduces Python-based scripting. This gives advanced users more control over automating workflows and integrating Howler with other production tools, pipelines, or custom plugins. Python scripting opens up new possibilities for tool customization, batch processing, and repetitive task automation, which will be a welcomed feature for anyone handling complex projects.

The update also includes new Video FX Filters that enhance post-processing. These filters allow for advanced color grading, noise reduction, and stylized looks that are typically used in final renders. Integrated GPU support ensures that these effects can be rendered in real-time, making it easier to preview the final output before committing to a render.

Pricing and Licensing
Howler 2025 is available under a one-time purchase model, with the base price starting at $99. Professional users can opt for an enhanced version with additional FX tools and AI capabilities for $149. Licensing is non-subscription-based, which could appeal to users looking for a more predictable, long-term cost structure.

You can learn more about Howler 2025 by visiting Project Dogwaffle and reviewing the full product documentation.

The post Howler 2025 Released first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

The “Quad Maker” add-on is designed to optimise the retopology process in Blender. It offers functions that enable more efficient modelling. The main features are the automatic recognition and adaptation of topology patterns and the simplification of complex meshes. This promises to improve the way VFX artists, game designers and other users work.

The Quad Maker integrates seamlessly into Blender’s existing user interface and complements it with new tools for the creation of topology quads. Using the add-on saves time and effort by automating repetitive retopology tasks. Another feature is the option to analyse and improve existing topologies. This can be particularly useful for optimising existing models for animations or game engines by removing unnecessary polygons and making mesh structures more efficient.

The tool offers various presets that can be customised depending on the application. Users can define specific topology presets to maintain precise control over the final result. These presets are helpful when different requirements are placed on models, such as organic shapes or technical models. In addition, Quad Maker can be integrated into existing Python-based scripts, which increases the level of automation.

Another highlight is the add-on’s ability to retain the original shape of the model while adapting the topology. This ensures that the artistic expression of the original is retained in the retopology. The automatic recognition of edge loops and polygon areas helps to further reduce working time. The tool makes it possible to focus on the creative aspects of modelling instead of wasting time on technical details.

Before using Quad Maker in ongoing projects, each function should be thoroughly tested to ensure that it fulfils the requirements and does not cause any unexpected problems. The results of the add-on are based on algorithms and techniques that, although advertised as efficient by the developers, may not be optimised for every possible requirement.

Licence model and pricing

Quad Maker is available as a paid add-on. Licensing terms and pricing vary, with both single user and team licences available. Details on prices and licence models can be found on the manufacturer’s website.

More information about the Quad Maker add-on.

The post Blender add-on “Quad Maker” for more efficient retopology first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

The term “pipeline” is made up of “pipe” and “line” and describes a process in which something goes in at one end and comes out at the other. It is often used in the fields of visual effects, animation and games, but “workflow” is also a good synonym. Pipelines can be very different. They can range from a 3D software rendering pipeline to a production pipeline. A production pipeline is there to manage the workflow and data output at each stage.
Pipelines are the secret to collaboration. They connect different departments together. Often artists don’t understand how these magical tubes work or how to connect them. But don’t worry, we’re here to shed some light and unlock the secrets of the pipeline!
Teamwork made easy

In every new project, artists face the challenge of teamwork. Even if we are masters in our art, that doesn’t mean we are automatically team players. This is where the pipeline comes into play! It creates standards and workflows so that every artist can work freely within clear expectations. A well-functioning pipeline reduces friction and allows artists to focus on their creative work, while the transition between departments is (ideally) buttery smooth. By minimising redundant tasks, we can focus on the really important things. This means fewer mistakes because we’re not constantly repeating the same work clicks and less stress because everything runs like clockwork. A well-planned pipeline ensures that everyone knows their role and everything goes hand in hand. This leaves more time for creative explosions and less time for organisational headaches.

Everyday life in the pipeline

There are many moments in everyday production when we have to focus on uncreative tasks. Imagine doing this over and over again: opening certain menus, navigating to folders, executing commands or waiting for processes to be completed. It may sound boring, but these routines are our safety net. They give us security and stability so that we can realise our creative ideas without crashing.
With a pipeline behind us, we can focus on what really matters – our art. So, let’s celebrate the magic of the pipeline and make collaboration a smooth and stress-free dance! To create our own pipeline, we need to take a closer look at the following four elements:

Folder Structure

Every pipeline starts with the folder structure, the files are the essential glue between and representation of each department’s work. The first question we ask ourselves when working with our project files is “Where do I store my files?”
The folder structure defines the folder names, their hierarchy and the content of each folder. Depending on the production and studio, this can be customised as required.
Task-based: The task-based approach is best suited to specialised teams where tasks are strictly divided into departments so that artists have a simple “everything in one place” structure. Assets and shots are organised under tasks. (ASSETS/RIG/Shots)
Asset-based (most common): The asset-based approach allows for easier switching when each artist is working on multiple tasks at once. A great generalist approach for smaller projects. (ASSETS/Mike/RIG)
Further planning folders provide space for production data such as asset/shot spreadsheets and budgets, while Preproduction is where we store artwork and mood boards as well as footage, where we find general project-independent resources to help with asset and shot production.

A project folder structure can be divided into the following categories:

Naming Convention

Now that we have organised our files into different project folders, we need to answer another question: How do we name the working files, texture files, assets, shots and nodes in the scene? These questions are answered by the naming convention, which defines general and specific rules for certain types and phases of the project. These rules must answer all naming questions to avoid confusion and help in the later stages of script development. General naming conventions
could be:

• English
• camelCase (ragingBull)
• no spaces “” instead underscore “_” in the file name
• Tasks are in CAPITAL LETTERS (RIG)
• Versions are a “v” combined with 3 digits (v001)
• no names and comments in the file name (are saved as metadata)

Tasks can be shortened for use in asset and shot files:

Short	Long
GEO	Modelling
SHD	Shading
TEX	Texturing
RIG	Rigging
ANIM	Animating
FX	Effects
LGT	Lighting
RENDER	Rendering
PRE	PREVIZ
SLAP	SlapComp
COMP	Compositing
	Editing
GRAD	Grading

Here is the final result for our project files using the naming conventions:

Working file: name_TASK_version.extension
mother_RIG_v001.mb
Render file: shotNr_AOVs_version.####.extension
s010_diffuse_v001.1001.exr

Software pipeline

Now that we have structured our project and naming conventions inside and outside the scene, it’s time to look at the software and plug-ins. The software pipeline defines the software, its versions, the files and how they relate to each department. The purpose of the software pipeline can be summarised quite simply by defining what goes in, what comes out and what software is used in the middle of the process. The result is that every artist uses the same tools and plug-ins, while the data flows clearly to and from each department.

Software

Software version (Maya 2025, Houdini 20)
File format per department (input & output)

TASK	INPUT	OUTPUT
GEO	.abc	.mb
TEX	.abc	.tiff (8 bit)/ .exr (16 bit)
SHD	.mb	.mb
RIG	.mb	.mb
ANIM	.mb	.mb/.abc
LGT	.mb	.mb
RENDER	.mb	.exr (16 bit)

Extras

Start Frame: 1001 (pre-run time for simulations)

Frame handles: 5 (pre- and postrun time for the edit)

Script Pipeline

We have now reached the final stage of our pipeline: the script pipeline. This is what most people think of as a pipeline. In reality, this is only partially true. The previous sections are much more important and essential to creating a pipeline than the scripts that support it. The purpose of the script pipeline is really just to automate what has been defined by the folder structure, naming convention and software pipeline. The Script Pipeline helps our “Studio Pipeline” with the following tasks:
Folder Structure: Creating folders and organising the working files.
Naming Convention: Save, load, import and export files using a standardised naming convention within and outside the scene.
Software Pipeline: Opens the appropriate project software and loads the required plug-ins, scripts and files via import and publishing applications.

The script pipeline automates the previous steps and realises implementation smoothly. Even the best folder structure, naming convention and software pipeline can be ignored by a single artist. Automating these processes with scripts eliminates manual errors and additional training while saving time, allowing the artist to focus on their craft and not on data processing.

Successful pipelines

The key to a successful script pipeline is automating these 3 elements:

• Software setup at startup
• Save & Load
• Export & Import

Launching the right software with the required plug-ins, settings and scripts ensures that all team members are working with the same applications. Saving, loading, exporting and importing enforce the pipeline structure, simplifying work and publishing to other departments.

“One of the biggest mistakes we made was trying to automate things that are super easy for a person to do, but super hard for a robot to do.”
– Elon Musk

On the other hand, we tend to see certain automations as the only way to get things done, without realising that we can achieve the same results with little preparation and a simple manual workflow. Studios tend to be plagued by the same issues, but they remedy this with pipelines that automate as much “idle time” as possible to increase artist productivity.
The best time to create a script pipeline is after a thorough review of the previous three phases to determine which part will benefit from automation, as automation is time-consuming and comes with its own challenges.

(is.gd/xkcd_efficency)

Extras

Finally, a few points that may be extremely important when looking at the pipeline of a project and that you should definitely keep in mind.
Onboarding: The introduction of new employees to a project should always be a priority at the beginning. In addition to the familiarisation period, it is important to show them how the pipeline works specifically for their work and at the same time give them the opportunity to read about this in the pipeline documentation. (For example in the Open Source Pipeline Plex Wiki – is.gd/plex_wiki)

Backup: It is always advisable to make several backup copies of our project in case we lose it or need to revert to a certain state. Every operating system offers backups with timestamps, or you can simply use Google Drive or Dropbox to save a copy in a remote location. For Script Pipeline, git (www.git-scm.com/) is the best backup system as it allows a tremendous amount of control over backups, changes and rollbacks.

Simple automation: A variety of free and paid external tools can take over certain tasks and create a simple script pipeline. For example, tools such as Total Commander, Directory Opus, the Element or Adobe Bridge can be used to rename or move a large number of files according to a specific logic.

Conclusion

Pipelines are a key element in any production of visual effects, animations and games. A good pipeline guides the artist through the complexity of a multi-stage project and can mean the difference between meeting or missing a deadline. A bad pipeline adds complexity, confusion and unnecessary steps that slow down creativity, teamwork and progress.
To create a good pipeline, it’s important to be clear about the project and have enough experience from previous projects to plan a workflow in advance that guides everyone involved from script to final cut. It’s not just about automation and scripts, because a smart and clear workflow can achieve similar results without relying too much on programming. Ultimately, it’s about achieving the result as smoothly as possible.

The post Baby’s first pipeline first appeared on DIGITAL PRODUCTION and was written by Alexander Richter.

Blender 4.2 LTS brings significant improvements to the user interface and workflow to increase efficiency and ease of use. The new Asset Browser panel makes it easier to manage and organise assets, streamlining access to frequently used files. These improvements are designed to streamline and speed up the workflow for artists.

Render engines and cycles

The Cycles render engine has been further optimised. Path guiding for complex lighting conditions and improved caustics increase performance and enable a more realistic representation of light and shadow. New hardware accelerators ensure faster render times.

Geometry nodes and simulations

Geometry nodes have been enhanced to create more complex and dynamic effects. Artists can create procedural models and animations more efficiently, and the new simulation tools allow for more detailed physics simulations, such as fluids and smoke. Geometry Nodes Documentation – Comprehensive documentation on the geometry nodes in Blender.

Script extensions and Python APIs

Extended Python APIs offer more options for automating and customising the workflow. This facilitates the integration of Blender into existing production pipelines and fulfils specific requirements more efficiently. Blender Python API – Up-to-date documentation of the Python APIs in Blender.

Future-proof implementation

The new features in Blender 4.2 LTS should be tested and validated before being used in projects to ensure they meet production standards and avoid unexpected complications. Long-term support (LTS) guarantees regular updates and bug fixes for greater stability and reliability in professional environments.

Let’s talk Eeveee

Blender 4.2 brings a significant improvement in real-time rendering quality with Eevee Next. New features such as global illumination, motion blur and unlimited light sources are supported. One of the most significant innovations in Eevee Next is the new global illumination system, which is based on screen space ray tracing. This method increases the accuracy of indirect lighting of surfaces and enables more realistic renderings. Ray tracing is now used for every BSDF shader in a scene, resulting in a significant increase in visual quality. Eevee Next also improves temporal stability during rendering. Noise and aliasing issues are reduced through velocity-aware temporal supersampling, resulting in more stable and flicker-free renderings. In addition, shadows are now rendered with virtual shadow maps, further reducing flicker and increasing maximum shadow resolution.

Support for unlimited light sources and new features

Compared to previous versions, Eevee Next removes the limitation of light sources. An unlimited number of light sources can now be used in a scene, with up to 4,096 light sources visible at the same time. Additionally, lights are now visible through refractive surfaces, increasing the flexibility and realism of the lighting. Eevee Next now supports displacement on materials, which opens up the possibility of displaying surfaces more realistically. A new thickness output function improves the visual quality of refraction, translucency and subsurface scattering. Motion blur is now partially supported in the viewport and uses a simpler algorithm than in final renderings. This allows artists to visualise and optimise motion blur in real time.

Revised user interface and compatibility

Eevee’s user interface has been redesigned to make it easier to use and to bring it closer to the panels and features of Cycles. However, there are still differences in the functions of both render engines. A full list of remaining limitations can be found in the Eevee Next online documentation.

Requirements and availability

Eevee Next is part of Blender 4.2 and is currently available as a release candidate. The stable version will be released on 16 July 2024. Blender is compatible with Windows 8.1 , macOS 11.2 and glibc 2.28 Linux and is available free of charge.

Sources

• Blender Developer Blog: Announcement of Eevee Next
• Blender 4.2 Release Notes: New features in Eevee Next
• Migration Guide: Switching from older Blender versions to Eevee Next

New fee structure in the Blender Market

Commissions in the Blender Market will increase from 30% to up to 35% without prior notice, depending on the seller’s revenue. This could affect the pricing of assets and plugins that are important for VFX projects.

Plan	Monthly fee	Commission rate	Transaction fee	Merchant fee
Free of charge	$0	70%	$0.49	5.5%
Per	$49	80%	$0.49	5.0%
Ultimate	$199	90%	$0.49	4.0%

Links

• Blender 4.2 LTS Release – Official announcement and detailed information about the new features in Blender 4.2 LTS.
• Blender Asset Browser – Documentation and usage of the new asset browser in Blender.
• Cycles Render Engine – Official website of the Cycles render engine with detailed information and resources.

New fee structure in the Blender Market

The fee adjustment affects the commissions that Blender Market Official Site charges to sellers. The change was implemented without prior notice, which caused displeasure in the community. Commissions will increase from 30% to up to 35%, depending on the seller’s turnover. This increase could affect the pricing of assets and plugins that are essential for the production of VFX projects.

How merchant and transaction fees are calculated

Merchant and transaction fees are charged by payment processing companies on every transaction. Merchant fees are a percentage of the transaction amount, while transaction fees are fixed amounts.

The amount of the merchant fee depends on whether you have a Blender Market subscription plan and which plan you use.

Plan	Monthly fee	Commission rate	Transaction fee	Merchant fee
Free of charge	$0	70%	$0.49	5.5%
Per	$49	80%	$0.49	5.0%
Ultimate	$199	90%	$0.49	4.0%

The merchant fee is calculated based on the product price and deducted from the product price.

Formula for calculating the commission:

Example: A product worth $25 would incur the following merchant fees:

• Free Plan (5.5%): $1.38
• Pro Plan (5.0%): $1.25
• Ultimate Plan (4.0%): $1.00

Impact on the VFX pipeline

Blender Market is an important resource for Blender users looking to enhance their projects with additional assets and tools. Many studios and artists use the platform to make their production pipelines more efficient. The increase in fees could lead to some providers raising their prices, which in turn puts pressure on studio budgets. Small and independent artists in particular could find it difficult to bear the additional costs or pass them on to their customers.

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

In nuce: Rocket Square releases version 2.0 of its RS Built Kit for Maya. It is a Python tool that allows you to perform powerful functions in terms of mesh, layout, import, export and curves. Rocket Square is an online platform that provides you with Python tools designed to simplify your work with Autodesk Maya.

Who is behind Rocket Square? The creative mind behind Rocket Square is Erik Lehmann. He is a 3D artist with over ten years of experience in the VFX industry. He is currently a Senior Modeller at Scanline in Vancouver. Previously, Erik has worked for Double Negative, Framestore, Cinesite, Imagine Engine and MPC. In the course of his engagements, Erik has been involved in blockbuster productions such as Blade Runner 2049, The Jungle Book, Game of Thrones and Guardians of the Galaxy. You can visit the talented artist on his homepage or on Twitter.

Pricing: The single licence of Built Kit 2.0 costs 30 US dollars, the eight-user indi licence is priced at 210 US dollars, and the studio licence starts at 1,500 US dollars. By the way: If you already own the Build Kit 1.0, you will receive a 20-dollar discount, as stated in the product description of the tool on Gumroad. To receive this discount, you must contact Erik Lehmann using this form.

Click further: You can get the RS Built Kit for Maya on Gumroad. The following video explains the new features of version 2.0.

RS Build Kit 2.0 – New Features Trailer

The post RS Build Kit 2 released first appeared on DIGITAL PRODUCTION and was written by Patrick Poti.

At the 3D and Motion Design Show, Maxon recently gave an insight into upcoming features – for Redshift, Red Giant and Cinema 4D. With Project Neutron, Python 3, USD, Redshift RT you can look forward to some new features in upcoming versions (even if, as usual, it will take longer until a complete end-to-end workflow is available and fully functional).

Cinema 4D: Project Neutron

With Project Neutron, the node-based workflow in Cinema 4D is to be more closely integrated. With the new engine, Maxon wants to enable new procedural modelling techniques, motion graphics and visual programming, but not “force” them. In other words, if you don’t have a direct application for it, you don’t have to familiarise yourself with new workflows. Similar to the Object Manager, the new functions will be optionally available via a new GUI. In the examples so far, the developers show animated sphere arrays, procedural forest landscapes and mesh workflows, as well as procedural fish swarms, dual mesh functions and more. Project Neutron will be available for the first time as a Tech Preview in the upcoming Cinema 4D R22 versions. An exact release date for the autumn, as well as feature scope is not yet available.

Python 3 and USD support

Things are also continuing in other important areas – in line with the requirements of the VFX Reference Platform, the Python 3 standard is already part of many DCCs. According to Maxon, most of the changes should be backwards-compatible in order to minimise the transition from 2.7.7 to 3.7.7 for pipeline TDs and developers – at least in theory. You can find more information on this here on the Maxon blog.

While Maxon has taken care of the exchange around the Cineware plug-ins, the next version of Cinema 4D will now also be able to import and export USD formats. In the preview, this includes geometry, materials, cameras and lighting. The supported formats are…

• USDC binary files
• USDA ASCII file format
• USDZ format (for augmented reality applications)

Availability

After the new subscription-only C4D S22 version, the update for the next perpetual Cinema 4D Release 22 is still pending for this year. A permanent licence (R21) currently costs 3364 euros, the annual subscription starts at just under 58 euros.

Further information: To the official Maxon website

The post Cinema 4D: Project Neutron announced first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

Houdini can read in external data in various ways. The most comprehensive is certainly a self-written Python parser, but that is not necessary here, because Houdini comes with the Table Import Node as standard. This makes it possible to import tables in CSV format. If you look under the bonnet of the table import node, you will of course find a Python script there anyway. This is one of the reasons why I like Houdini so much: almost everything is open and can be studied or adapted to your own needs.

Import

The CSV format contains values that are separated by commas (CSV = comma separated values). These can be words or numbers. Most spreadsheet programmes can save or export tables as CSV. I use Google Sheets here, and it works great: the table import node initially only creates points, which then contain these values in attributes. I use the attributes:

@word, @pscale, @font.

@word gets the values from column A, which is the first column. In Houdini, counting usually starts with zero, hence Column Number 0. The attribute type is a string.

@pscale is a special attribute specified by Houdini. @pscale stands for Point Scale, i.e. the size of a point. This is Column Number 1, and the type in this case is a float, i.e. a floating point number. I could therefore also have entered 1.5 or 2.3 as values in the table.

i have defined @font as type integer, i.e. as an integer. As I want to use three different fonts, I have entered 0, 1 or 2 as values in the table.

The Table Import can also translate (e.g. Lat/Long to Sphere), but the Translator is not needed here.

The second node is Enumerate. This creates an @index attribute with which the points are counted in order to be able to assign them later. The group type must be changed from “Primitives” to “Points”. The next two nodes are not absolutely necessary, but as I wanted to create other sizes and these should be somewhat random, I first used Attribute Expression to convert the @pscale values 1,2,3 into 1.5, 2 and 2.5. To do this, “Custom” must be entered in the node attribute and “pscale” as the name and “Float” for the type. I use the VEXpression for this: “1 self * .5”.
And of course, I could have entered these values in the table straight away, but I didn’t. The zero named here as “OUT_points_with_attributes” is not necessary for the function, but is part of good style.

Loop it!

Now the first loop comes into play. This is a For Each Point loop. It contains 3 font nodes, one for each font. Firstly, I created a font node for this and added the spare input required later. To do this, click on the cogwheel and select “Add Spare Input”.

This font node was then referenced twice using drag-and-drop with the Shift, Ctrl and Alt keys held down. For the copies, I then held down the Shift and Ctrl keys and clicked on Font to remove the reference link. Alternatively, this can also be done with the right mouse button menu and “Delete Channels”.

Fonts

The most important node when it comes to text is of course the font node. It can generate both polygons and Bezier curves or both at the same time. I use polygons here. I have set the level of detail to 4 so that the tessellation is nice and fine.

Working with Bezier curves is also great, but unfortunately not useful here, as the UV layout node used later cannot process them. Now it gets a little more magical or technical. In the “Spare Input0” parameter, the “../foreach_begin1” node is referenced by drag-and-drop or, if you want and like typing, you can do that too. The text to be created is normally simply entered in the text field, but we want to read it in from the CSV table, which has already been converted into points. Backticks can be used here to execute code.

The command required here is “points”, whereby it is not about several points, but about string values from points. The “s” at the end stands for “string”. The first spare input is addressed with “-1”. The zero after it is the first point, here it is always just one point anyway, as we are looping over the points. Then “word”, because we want to read the @word attribute. Brackets around it and a backtick and that’s it.

As an aside and for the sake of completeness, “Add Text Attributes” should also be mentioned here. It is not needed here, but is very cool for other text gimmicks. If the box is ticked, the attributes @textindex, which indicates the number of letters in the word, and @textsymbol, which indicates which letter it is, are created for each letter or primitive. However, this is an ASCII value, i.e. a number. “f”, for example, is then 102.

The three font nodes are then connected with a switch that reads the @font attribute. I have also created a spare input for this. This time it is the “point” command and not “points”, as only a number is read out here and not a string. So “point(-1,0, “font”,0)”. In this case, “-1” is again the spare input, “0” is the first point, “font” is the attribute and the last “0” is a necessary argument, which doesn’t really make sense here. However, if we wanted to read out a vector, “0” would be X, “1” would be Y and “2” would be Z. This is also only mentioned here for the sake of completeness.

Copy to points

Okay, Houdini! Now we come to the copy to points node. First of all, some information in passing: This node will change a lot in H18 and make actions like this easier. No matter. Pack and Instance is not needed here. Transform Using Point Orientation is also not required here, but can also be on. Copy Points Attributes is used because we still need @index. So enter “index” under Set/To Primitive. Delete everything else.

Now you should be able to see a bunch of fonts on top of each other. Before, there was nothing to see in the viewport except a dot in the centre, at most. Tip: In the “foreach_end1” node you can set to “Single Pass” for debugging, then only one iteration of the loop is executed. And always keep an eye on the geometry spreadsheet, where you can see the values of attributes.
Now we come to the UV layout node, which is used here to distribute the words in a shape. In the picture, I have coloured the shape green. I have left space for the two logos of DP and DIGITAL PRODUCTION. Connecting this shape to the second input of the UV layout node should not be too complex. Of course, the words with the @index attribute go into the first one.

UVs

The UV layout node normally uses the @island attribute to delimit the UV parts from each other and the @uv attribute for the positions of the vertices on the UV map. Since there are no UV coordinates here at all, we replace “uv” twice with “P”.

in Houdini, @P is the position of the vertices. For Axis Alignment we select “none” and for Island Rotation Step we set “No Rotations”. If you want to create a Word Cloud with rotated words, they should either be rotated beforehand or you should select 90°, for example, so that no words are upside down.

Padding is the distance between the shapes to be distributed, in this case words, and Scale should be set to “Largest Packable”. The “Advan…” settings are also interesting. This must stand for Advanced. There are iterations here. Here the node randomly tries different layouts and then uses the layout with the best space utilisation. However, each iteration takes time, and 4 is sufficient for this purpose. Different layout versions can be generated with “Random Seed”.
That’s it as far as the layout is concerned, but now we want it in 3D. To switch to a so-called Packed Workflow, we need an @name attribute with a string, i.e. text content. At the moment, we only have an @index attribute, and these are numbers. We do this with an attribute wrangle node.

Select “Primitives” under Run Over and enter the following VEXpression: “s@name = sprintf(“%d”, i@index);”. This creates an @name attribute, which then contains the number as a string. For more details on this VEX function, please refer to the Houdini documentation, which would go beyond the scope of this article.

Now the whole thing is packed, i.e. each word is now represented by a point. This is practical because it is now easier to select the words, for example, in order to make manual corrections to the positions. Simply use an Edit Node to do this.

Before or after the edit node, I used an attribute copy node to write the attributes from the beginning @font, @pscale, @word back to the points, which now contain the packed geometry. Again, @index is used to assign the source and target points (Attribute to Match). Only @pscale is actually needed, but never mind. If you want, you could customise this even more variably and select words more easily or, for example, extrude them differently depending on the font.
Now rotate another loop and extrude the words. To do this, create a For-Each Primtive Loop and place an Unpack followed by a Pack Node. A polyextrude is placed in between.

Then either drag and drop the “foreach_begin3” into the spare input created or enter “../foreach_begin3”. I have set the parameter “distance_multiplier” to 0.025.
The magic is in the Distance parameter; enter “point(-1,0, “pscale”,0)*ch(“distance_multiplier”)” enter. Now @pscale is used to control the thickness of the letters. Do not forget to tick the “Output Back” box, otherwise the letter will be open at the back.

Finally, a file node to save the geometry. It can then be integrated into the rendering scene. The outline plate behind the words was also created procedurally, unfortunately no longer part of this article. But this much can be revealed: I converted a geo into a volume, more precisely into an SDF/VDB. Then enlarged it as an SDF or made it thicker. Then “vdbsmooth” and converted it into a mesh. An Intersection Aanalysis followed by Polypath, then Resample, then Fit and Resample again, and the outline is ready.

Outlook

I would also have liked to have written something about splines, i.e. curve modelling and editing. This works very well in Houdini, even if it takes some getting used to. I would also have liked to discuss rounded edges. But I ran out of pages – we’ll just do that in one of the next issues.

The post Blergh! Word Art! In Houdini? first appeared on DIGITAL PRODUCTION and was written by Olaf Finkbeiner.

With the fresh 12.0 update for Foundry’s DCC software, Modo receives many improvements to the integrated modelling tools, UV improvements, new interface & viewport updates, as well as Python scripts and export options. The announced VR features will only appear in later releases.

Modelling Features

In addition to new “randomise” functions for the jitter tool (modelling & UV), Mesh Paint now has three new modes: Linear, Radial and Array and also offers the possibility to use duplicated and instanced geometry. Selected objects from the Preset Browser can now also be randomised using a “Randomizer”.

Surface Strips is a brand new tool for MeshFusion. You can use it to convert the topology at the intersection of two Boolean meshes into quads or use Surface Strips as a Boolean operation that creates open bodies with quad edges.

Foundry has also added new mesh operators for the procedural modelling introduced in Modo 10. These include a Triangulate MeshOp for non-destructive export, the ability to use duplicated geometry as input for Merge Mesh, a new Falloff operator and more.

UV Tools

With the optimisation of the user interface, new UV Gaps function and revision of UV Align, Foundry has also added small improvements to the UV workflow. Multiple UVs can now be adjusted more easily at the same time.

Rendering & Shading

You can use the new Frame Range Channel to determine which frames of an animation should be rendered. In addition to support for the new glTF Material Shader, Modo now also offers a drop-down menu for shading models with PBR and Unlit settings.

Other new features

The viewport now includes a Topology preset to get quick access to the Retopo tools without having to switch to the Topolgy layout. Foundry has also added a selection of the Python Hatchet Collection to Modo, including PolyScale Offset, Polygon Flip, Flatten Ngon, Weight Map Slicer and more. You can read more about the Hatchet Collection here and in the release notes. Support for Gltf 2.0 has also been added to the export features – models can now be placed and shared in the Facebook newsfeed using drag & drop.

A complete update list can be found in the release notes.

Compatibility & Price

Modo is currently priced at €1460 for a permanent licence including one year of updates, subscription models cost €486 per year – with Maconcept’s Easter discount. If you are still a student, you can take a look at the cheaper & commercially usable Production Collective. This includes Nuke, CaraVR, Modo and Mari for €188 per year. Without the discounts, Modo permanent with one year maintenance comes to €1,619 plus VAT and Modo Subscription costs €539 plus VAT.

Modo 12.0 is compatible with…

• Mac OS 10.10.x, 10.11.x, and 10.12.x (64-bit)
• Windows 7, Windows 8, and Windows 10 (64-bit)
• Linux 64-bit (CentOS/RHEL 7 )

For more information: To the Foundry website

The post Foundry: Modo 12.0 released first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

The first video is about the basics of scripting in Nuke. In other words, how the scripting languages TCL and Python work and how they differ.

Then it gets practical, as he creates his own network that can be optimally customised to individual requirements. For example, with a script that automatically imports and rewrites external files.

You can read more tricks on how to make your pipeline faster in issue 05 : 2017. You can download Alexander Richter’s workshops from previous DP issues free of charge here: DP1505 Animan | DP1601 Droolpool | DP 1602 Animation Pipelines | DP1705 Pipeline4Artists

Update: Our downloads have moved – for technical reasons. You can find this file and all others, as well as additional web content from the magazine, free PDFs, Animago images, Video2Brain chapters and much more at:

http://download.digitalproduction.com

Sorry for the inconvenience!

The post Scripting for artists – Scripting in Nuke first appeared on DIGITAL PRODUCTION and was written by Bela Beier.