Start here

How Rhea works

Rhea has two ways of producing geometry, and they behave differently enough that knowing which one you are using saves a lot of confusion. This page is the three minutes that prevents it.

Two kinds of result

Some operations can be expressed as a rule that Blender itself evaluates every frame. Others require rebuilding the mesh from scratch. Rhea uses both, and is explicit about which is which.

The split is not a limitation being papered over — it is a real difference in what the operations are. You cannot express truncate every vertex of this polyhedron as a node graph that evaluates per frame, and you would not want a thousand-iteration relaxation solver running on every viewport redraw.

The effect stack

Live effects accumulate in a stack, shown in the Effects section. Each entry is one engine with its own controls, and each one runs on the output of the one above it.

  Blob                    ← your base mesh, never modified
   ├─ Rhea Symmetry       ← mirror, so patterns cross the seam
   ├─ Rhea Density        ← subdivision, so there is something to pattern
   ├─ Rhea Engine 1       ← Cells
   └─ Rhea Engine 2       ← Displace, running on the cells

Order matters and is editable: move an entry up or down and the result changes accordingly. Duplicate an entry to get two variations of the same engine. Remove one and everything below re-evaluates without it.

Full detail in Stacking effects.

Fields are the connective idea

A field is one number per vertex. That is all. Curvature is a field. Ambient occlusion is a field. So is a noise pattern, a distance from another object, or the output of a reaction-diffusion simulation.

Every generator can write a field, and every engine can be driven by one. This is why the modules combine the way they do without any of them knowing about each other:

• Run reaction-diffusion across a shell, then use its output to decide how tall each tessellated scale grows.
• Compute curvature, then use it to thicken lattice struts exactly where the form bends and needs bracing.
• Compute ambient occlusion, then use it to control Voronoi seed density so cells crowd into the recesses.

The full generator list is in Fields.

Where a field is stored

Fields are written onto the mesh as one of three things, and which you pick depends on what will read it back:

• Named float attribute — the default, and what the engines read. Full float range, no clamping.
• Vertex group — clamped to 0–1, but visible to every native Blender modifier, so you can drive a Displace or a Mask with it.
• Colour attribute channel — the one you can see in the viewport, and the one shaders read.

Why it is fast

Nothing in Rhea's compute path loops over vertices in Python. The whole core operates on numpy arrays: read the mesh into flat arrays once, do the work as whole-array operations, write it back once.

The practical consequence is that Rhea does not slow down gracefully as counts rise — it stays fast until it runs out of memory. A ten thousand face base with a hundred-vertex component, about a million vertices out, lands in roughly two seconds. An animated tessellation over five thousand faces rebuilds in under a tenth of a second, which is what makes timeline scrubbing possible at all.

There is no accelerator to install. There is no “click here to make it fast” that fails behind a corporate proxy. See Performance for the numbers and what to do when you exceed them.

What Rhea will not do to you

• It never modifies your base mesh in place while a result is live. Revert always gives it back.
• It refuses rather than hangs. Every operation projects its output size first and stops with a message if it exceeds the vertex budget.
• It never leaves orphaned mesh data. Replaced datablocks with no users are removed explicitly.
• It never writes to linked or library-overridden meshes. It says so instead.
• It never phones home. There is no telemetry, no licence check, and no network permission in the manifest.