BVH in Blender: the bounding volume hierarchy in Cycles and the .bvh motion capture file

Menu names below are checked against the Blender 5.2 manual and source code.

BVH: two meanings that have nothing in common

The same acronym covers a rendering concept and an animation file format. Figure out which one you need first:

What is a bounding volume hierarchy?

A ray tracer like Cycles has to find, for every ray, the first surface it runs into. Testing every triangle against every ray is out of the question once a scene has millions of triangles. A bounding volume hierarchy (BVH) avoids that work: it is an acceleration structure, built once before rendering, that every ray then walks through. For the bigger picture of how rays are traced, see path tracing vs ray tracing.

Nested boxes, and rays that skip whole branches

A BVH is a tree. Primitives (triangles, curve segments, points) live in the leaves, and each node stores the bounding box of everything beneath it, up to the root, whose box encloses the whole scene. The renderer tests the root box, then the boxes of its children. Whenever a ray misses a box, the entire subtree inside it is skipped without a single triangle test, and only the primitives in the leaves the ray reaches get tested.

In a standard BVH, each primitive appears only once, but the boxes of two sibling nodes can overlap, and a ray crossing the shared region has to visit both branches. Building a good BVH is mostly about keeping boxes small and overlaps rare.

Building the tree: the surface area heuristic (SAH)

To split a group of primitives in two, BVH builders use the surface area heuristic, which estimates the cost of ray intersection tests for each candidate split: the probability that a ray crossing a box also crosses a smaller box inside it is proportional to the ratio of their surface areas. According to Physically Based Rendering, Goldsmith and Salmon first estimated that probability from surface area in 1987, and MacDonald and Booth introduced the SAH in 1990. Cycles’ own BVH2 builder picks its splits this way.

Spatial splits, described by Stich and colleagues in 2009, also let the builder split a primitive itself when the SAH says it pays off, so a large triangle can end up in several leaves. Boxes overlap less and traversal gets faster, but the build takes longer and the tree uses more memory. That is the trade-off behind Cycles’ Use Spatial Splits option.

The BVH in Cycles: who builds it, on which device

Cycles builds its BVH on two levels: one per piece of geometry (“Updating Geometry BVH” followed by its name), then a scene BVH that places the objects (“Updating Scene BVH”). The structure depends on the compute device:

You make these choices in Edit > Preferences > System > Cycles Render Devices: the HIP RT checkbox under HIP, Embree on GPU under oneAPI, MetalRT (Off, On or Auto) under Metal. On an RTX card, handing BVH traversal to the RT cores is precisely what separates OptiX from CUDA; the guide to OptiX vs CUDA in Blender covers the rest.

For a final render (F12), Cycles builds a static BVH, which its source describes as slower to build but the fastest to render. In the viewport’s Rendered mode, it keeps a dynamic BVH that it refits (“Refitting BVH”) when you move an object.

Acceleration Structure settings in Blender 5.2

Open Render Properties > Performance > Acceleration Structure. What the panel shows depends on your device, and it disappears when OptiX is the only active device, because OptiX builds its own structure.

• Use Spatial Splits (CPU and GPU, off by default): faster rendering in scenes that mix large and small polygons, at the cost of longer BVH builds and slightly more memory. With Embree, it switches final renders to the highest build quality.
• Use Compact BVH (CPU, off by default): a more compact structure that saves RAM but renders slower. It has been optional since Blender 3.1.
• Use Curves BVH (GPU, on by default): a BVH whose boxes are not axis aligned, so they hug hair and fur more closely. Turning it off saves memory but slows down curve rendering.
• BVH Time Steps (GPU, 0 by default, up to 16): splits moving primitives into time steps for motion blur; faster, but hungrier for memory. Grayed out while Use Spatial Splits is on.

The presets menu in the Performance panel header sets everything at once. Faster Render turns on Persistent Data and Use Spatial Splits and sets BVH Time Steps to 2; Lower Memory turns on Use Compact BVH and drops the tile size to 512 pixels.

Why “Building BVH” takes so long at the start of a render

Between pressing Render and the first sample, the render’s info line runs through the preparation: Synchronizing object (Cycles receives the evaluated meshes, modifiers included), then Updating Geometry BVH and Building BVH for each piece of geometry, with a percentage on the CPU, and finally Updating Scene BVH.

How long it takes depends first on how many primitives there are. The Subdivision Surface modifier has two levels, Viewport and Render; the Render level is the one that counts, and every extra level multiplies the face count. Hair and child particles add large numbers of curves. Use Spatial Splits lengthens the build on purpose, and the static BVH of a final render takes longer to build than the viewport’s.

How to cut BVH build time

Persistent Data for animations

By default, Cycles throws away its copy of the scene after each frame to keep memory use low, so the next frame starts from scratch, BVH included. Turn on Render Properties > Performance > Final Render > Persistent Data: the manual says render data then stays in memory for faster animation renders, at the cost of extra memory while you work on other things. In the Cycles code, only geometry that changed goes through a BVH build again. With several view layers, only one is kept.

Instances instead of copies

A linked duplicate (Alt+D) with no modifiers, an instanced collection and a Geometry Nodesinstance all share one piece of geometry in Cycles, so one geometry BVH; the scene BVH just places each copy. A thousand instanced trees cost one tree to build, a thousand full copies cost a thousand. One catch: an object with modifiers enabled for rendering gets its own geometry, even when its mesh data is shared.

Less geometry at render time

• Tick Render Properties > Simplify and, under Render, lower Max Subdivision and Child Particles.
• Under Simplify > Culling, Camera Culling drops objects outside the camera view and Distance Culling those too far away, as long as Use Camera Cull or Use Distance Cull is ticked in Object Properties > Visibility > Culling. A culled object never reaches the Cycles scene, so it casts no shadow and shows up in no reflection.
• Leave Use Spatial Splits off for test renders, where preparation weighs more than sampling.

For the other levers, from samples and bounces to denoising, see how to render faster in Cycles.

The BVH file (Biovision Hierarchy): motion capture data

The other BVH is a file format. Biovision, a motion capture services company, created it to deliver data to its customers, replacing its earlier BVA format. It describes a skeleton, then the value of every joint on every frame. Blender can import and export it.

File structure: HIERARCHY, then MOTION

A BVH file is plain text with two sections. Here is a stripped-down example with two joints:

HIERARCHY
ROOT Hips
{
  OFFSET 0.00 0.00 0.00
  CHANNELS 6 Xposition Yposition Zposition Zrotation Xrotation Yrotation
  JOINT Spine
  {
    OFFSET 0.00 10.00 0.00
    CHANNELS 3 Zrotation Xrotation Yrotation
    End Site
    {
      OFFSET 0.00 15.00 0.00
    }
  }
}
MOTION
Frames: 2
Frame Time: 0.033333
0.00 35.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00
0.50 35.10 0.00 1.20 0.00 0.00 2.00 0.00 0.00

• HIERARCHY describes the skeleton at rest: ROOT names the root, JOINT each child joint, nested under its parent, OFFSET its position relative to the parent, and End Site closes a chain.
• CHANNELS declares how many animated values a joint has and in what order: in practice six for the root (position and rotation) and three for the others (rotation), often in Z, X, Y order.
• MOTION starts the data: Frames is the frame count, Frame Time the duration of one frame (0.033333 seconds means 30 fps). Each following line is one frame, with the values in CHANNELS order: 6 + 3 = 9 here.

Blender’s importer reads rotations in degrees. The format only defines translation offsets between parent and child, with no rotation in the rest pose.

How to import a BVH file in Blender

The importer is the BioVision Motion Capture (BVH) format add-on, which ships with Blender and is enabled by default. Go to File > Import > Motion Capture (.bvh) and set the options in the file browser’s sidebar:

• Target: Armature (the default) creates an animated armature with one bone per JOINT, named after it; Object creates one animated empty per joint.
• Scale (1 by default) multiplies every distance: this is where you fix a skeleton that comes in huge or tiny.
• Rotation: Euler (Native), the default, keeps the file’s rotation order; Quaternion or a fixed Euler order are available.
• Forward and Up (-Z and Y by default) convert the axes: Blender is Z up, while many applications are Y up.
• Start Frame (1 by default): the Blender frame where the motion begins.
• Scale FPS resamples the motion to the scene frame rate; otherwise each file frame maps to one Blender frame. Loop makes playback cycle.
• Update Scene FPS sets the scene frame rate to the file’s (1 divided by Frame Time), which makes Scale FPS moot. Update Scene Duration extends the scene to the file’s length and never shortens it.

Where to find free BVH files

The go-to source is the CMU Graphics Lab Motion Capture Database from Carnegie Mellon University (mocap.cs.cmu.edu): 2,605 trials in six categories, from walking and running to sports, dance and two-person interactions. The site calls the data free for all uses; its FAQ adds that you may include it in commercially sold products but may not resell the data itself, even in converted form.

CMU distributes the database as ASF/AMC and C3D; its home page points to BVH conversions made by Bruce Hahn. According to the CMU team, toe and hand joints tend to be noisy, the finger joints in the skeleton are not actually captured, and the lowest-numbered subjects, from the earliest sessions, can be lower quality.

Retargeting the motion to your character

The imported skeleton moves, your character does not: an action drives bones by name, and the BVH bone names are not your rig’s. Blender has no dedicated retargeting tool, but constraints do the job:

1. Line up the BVH armature and your rig: same scale, same rest pose (a T-pose on both, for example), facing the same axis.
2. In Pose Mode, give each bone of your rig a Copy Rotation constraint that targets the matching BVH bone (Target: the armature, then the bone name), and give the hip bone a Copy Location to carry over the root motion.
3. Select the constrained bones and run Pose > Animation > Bake Action with Visual Keying (keys the final pose, constraints applied) and Clear Local Constraints (removes the constraints afterward).

If the rest poses differ (A-pose vs T-pose), copying rotations directly throws the limbs off. Auto-Rig Pro, a paid add-on, has a Remap tool that transfers a BVH to any kind of armature, guesses the bone mapping from names and can redefine the source rest pose. Working with bones is covered in the Pose Mode guide, Mixamo clips, which come as FBX, in the Mixamo to Blender guide, and building the armature that receives the motion in the guide to rigging in Blender.