Cinema 4D MoGraph in Redshift: Multi-Instance, Clone Colors and Per-Clone Materials
How to render large Cinema 4D Cloner setups in Redshift with per-clone colors and materials, based on Maxon's documentation:
- Instance mode: Render Instances become Redshift native instances; Multi-Instance goes further and handles all clones as one object, which Maxon recommends for tens of thousands of clones. Render Instance stays the fallback.
- Clone colors: enable Color mode on a Random Effector, then read RSMGColor with a Color User Data node (preset MoGraph > Color) in the Redshift material.
- Different materials per clone: feed RSMGID through an RS Mod node into the Selector of a Shader Switch. One material on the Cloner, several looks.
- Faster preparation: bake animated clones with a MoGraph Cache tag to .mog files, and export static scatters as Redshift Proxies, which load only when rays reach them.
- Rendering the job: on iRender 2x, 4x or 8x RTX 5090 or RTX 4090 servers you open the same Cinema 4D scene, check the clones in the Redshift RenderView, and render with caches kept at their usual paths.
Cinema 4D Cloners can create hundreds of thousands of objects, and Redshift can render them fast if the scene is set up the way Maxon intends. This guide covers which Cloner instance mode to use, how to bring MoGraph colors and other clone data into a Redshift material, how to give clones different materials from one Cloner, and how caching and Redshift Proxies cut the time spent preparing a frame.
Checked against the Cinema 4D and Redshift documentation, November 2026.
1. Which Cloner instance mode should you use with Redshift?
For large scatters, use Multi-Instance; for anything that does not work in that mode, use Render Instance. Plain Instance creates a full copy of every clone and only suits small counts (Maxon: Cloner object properties).
Instance, Render Instance or Multi-Instance?
What each mode does, based on Maxon's Cloner and Instance object documentation.
| Mode | What Cinema 4D creates | Limits | Use it for |
|---|---|---|---|
| Instance | Full duplicates. Each clone uses as much memory as a separate object. | Memory and scene preparation grow with every clone. | Small counts, or clones that must be edited as real objects. |
| Render Instance | One copy of the object plus references to it. Redshift converts them to its native instances. | Clones share the object's current animation state; no individual animation per Effector or Time Offset. | Large counts, and effects such as Dynamics that Multi-Instance cannot handle. |
| Multi-Instance | Same rules as Render Instance, but all clones are handled internally as one object, which reduces memory and speeds things up. | Has the Render Instance restrictions; some Cloner features, such as Blend mode, do not work. | Tens of thousands of clones such as trees or grass; works best when each clone has as few objects as possible. |
The figure shows the difference for six clones of the same tree.
With Instance, Cinema 4D builds six complete trees. With Render Instance it keeps one tree and five references, which Redshift turns into its own instances. With Multi-Instance it keeps one tree and a list of clone positions handled as a single object, which is why Maxon recommends it when cloning tens of thousands of trees or tufts of grass.
2. How to give MoGraph clones random colors in Redshift (step by step)
Color the clones with an Effector, then read the color in the Redshift material with a Color User Data node set to RSMGColor. These steps follow Maxon’s Redshift MoGraph example.
Settings checklist (copy or follow line by line):
Cloner ................. object to clone as child; mode from section 1 Random Effector › Parameter Color Mode ............ On Position .............. Off (Maxon example: color only) Redshift material (Shader Graph) Color User Data › presets › MoGraph > Color Attribute Name ........ RSMGColor Out ................... base color of the material
Step 1: Create the Cloner
Create a Cloner, add the object to clone as its child, and choose the instance mode from section 1.
Step 2: Add a Random Effector with Color mode
Add a Random Effector to the Cloner and enable its Color mode. Maxon’s example also disables Position so only the color changes.
Step 3: Apply a Redshift material to the Cloner
Apply one Redshift material to the Cloner and open it in the Shader Graph, with the Redshift RenderView running.
Step 4: Read the clone color
Add a Color User Data node, open its presets and choose MoGraph > Color. This fills the Attribute Name with RSMGColor. Connect it to the base color of the material (Maxon: Color User Data).
Step 5: Adjust and check
Change the Effector seed for a different color mix, or add a Color Correct node to shift the hue. Check a frame in the RenderView. If the colors do not appear on a Multi-Instance Cloner, compare with Render Instance mode, which is the mode Maxon’s Redshift example is built on.
Quick check: if all clones render in one color, confirm the Effector has Color mode on and that the Color User Data node reads RSMGColor; then compare Multi-Instance with Render Instance mode.
3. Which MoGraph attributes can Redshift read?
Besides color, Redshift exposes the clone index, weight, falloff, UVW and more through User Data nodes. The names below come from Maxon’s User Data reference.
Which MoGraph attributes Redshift can read in the Shader Graph
Attribute names as listed in Maxon's Redshift User Data reference. Pick them from the MoGraph presets of a User Data node.
| Attribute | Type | Value | Typical use |
|---|---|---|---|
| RSMGColor | Color | Clone color | Random or Field-driven colors from Effectors |
| RSMGID | Integer | Clone index | Pick a shader per clone with RS Mod and Shader Switch |
| RSMGIDNorm / RSMGIDRatio | Float | Clone index, 0 to 1 | Gradients across the clone order |
| RSMGWeight | Float | MoGraph Weight, 0 to 1 | Vary roughness or other values; set the Effector's Weight Transform above zero |
| RSMGFalloffWeight | Float | Falloff weight, 0 to 1 | Shading driven by a Field |
| RSMGUVW | Vector | Clone UVW | Map one texture across all clones |
| RSMGSize / RSMGTimeOffset / RSMGAltID | Vector / Float / Integer | Size, time offset, alternative ID | More variation from the same material |
4. How to assign different materials to clones from one Cloner
Connect several materials to a Shader Switch and let the clone index choose between them. Maxon’s example switches between four materials:
- Add a Shader Switch node to the Cloner’s material and connect four materials to its Shader 0 to Shader 3 inputs. Without a Selector input, the switch always uses Shader 0.
- Add an Integer User Data node set to the MoGraph clone index, RSMGID.
- Add an RS Mod node and set its Divisor to 4, the number of shaders, so the index wraps around.
- Connect the RS Mod output to the Selector input of the Shader Switch.
The figure shows why the RS Mod node is needed.
Clone indices keep counting up, but the Shader Switch only has four inputs. RS Mod with a Divisor of 4 turns 0 to 7 into 0, 1, 2, 3, 0, 1, 2, 3, so the clones cycle through the four materials. For subtler variation, connect a Scalar User Data node reading RSMGWeight to roughness, and set the Random Effector’s Weight Transform above zero so the weight actually varies.
5. Why does a MoGraph scene take long to prepare before rendering?
Before the first ray is traced, Cinema 4D has to evaluate the Cloner and its Effectors for the frame and pass the result to Redshift. With heavy MoGraph setups that preparation can take longer than the render itself. Two tools from Maxon reduce it:
Bake animated clones with a MoGraph Cache tag
Add the tag from Tags > MoGraph Tags > MoGraph Cache to the top-most clone-generating object. Baking stores position, rotation and scale so they are no longer calculated live. With Bake to file, the cache is written as one .mog file per frame, and relative paths and tokens such as $mobaketag can be used. Maxon recommends baking when rendering with Team Render, when Delay Effectors are used, or whenever the animation does not behave as expected (Maxon: MoGraph Cache).
Export static scatters as Redshift Proxies
For geometry that no longer changes, use File > Export > Redshift Proxy (*.rs) and place it with Create > Redshift Proxy. Proxies are stored in a format Redshift can use directly, load only when a ray reaches them, and have almost no scene translation cost (Maxon: Redshift Proxy object).
- A proxy cannot be deformed after export; only its position, rotation and scale can be animated.
- When you place many copies, instance one proxy instead of loading it again.
- Instanced proxies only support fixed tessellation.
- Only the vertex attributes used by the materials at export time are kept, and motion blur must be enabled when you export if you need it.
6. Where should you render heavy MoGraph scenes: SaaS or IaaS farm?
Both work once the scene is self-contained. A SaaS render farm, where you upload the scene and it is rendered for you, suits finished scenes whose caches and proxies are packed with relative paths. An IaaS render farm such as iRender, where you work on a remote machine, suits scenes you still want to open in Cinema 4D: checking clone colors in the RenderView, re-baking a MoGraph cache, or swapping a Cloner for a proxy. In both cases, make sure every .mog and .rs file travels with the scene, or the Cloner will be evaluated live again.
These videos show MoGraph-style Cinema 4D setups and Redshift jobs on iRender servers.
On iRender you rent a whole server with 2x, 4x or 8x RTX 5090 or RTX 4090 GPUs, with Cinema 4D and Redshift pre-installed; Prime members get activated Cinema 4D and Redshift licenses. Real render times are in our Redshift benchmark, per-light relighting is covered in Redshift light groups in Cinema 4D, and plans are on the Cinema 4D Redshift render farm page.
7. Redshift MoGraph FAQ
How do I get MoGraph colors in a Redshift material?
Enable Color mode on the Effector, for example a Random Effector, then open the Redshift material, add a Color User Data node, pick MoGraph > Color from its presets (attribute RSMGColor) and connect it to the base color. Each clone now renders with its own color.
Is it mograph_color or RSMGColor in Redshift?
Redshift for Cinema 4D uses the attribute name RSMGColor for the clone color. Other MoGraph attributes follow the same pattern, such as RSMGID for the clone index and RSMGWeight for the MoGraph weight. The easiest way is to choose them from the MoGraph presets of the User Data node.
Should I use Render Instance or Multi-Instance with Redshift?
Maxon recommends Multi-Instance for very large counts such as tens of thousands of trees, because the clones are handled as one object. Render Instances are converted to Redshift native instances and remain the fallback when a feature does not work as expected in Multi-Instance mode.
How do I give clones different materials with one Cloner?
Connect several materials to a Shader Switch node, read the clone index with an Integer User Data node (RSMGID), wrap it with an RS Mod node whose Divisor equals the number of materials, and connect the result to the Selector input of the Shader Switch.
What file does the MoGraph Cache tag write?
When you use Bake to file, the MoGraph Cache tag writes one cache file per frame with the .mog extension. Relative paths and tokens such as $mobaketag can be used in the file name. Keep the .mog files with the scene when you move it to another machine or a render farm.
When should I use a Redshift Proxy instead of a Cloner?
Use a Redshift Proxy for static geometry you place many times, such as a finished scatter or set dressing. Proxies are stored in a format Redshift can use directly and load only when a ray reaches them. They cannot be deformed after export, and instanced proxies only support fixed tessellation.
