VQFieldStart a pilot

VQFieldRandom-access compression for OpenVDB

Volumes that stay compressed while they render.

VQField shrinks OpenVDB volumes and sequences, and lets Karma CPU, your tools or your own renderer read them in place. Each request decodes only the 8³ block it touches. When a tool needs a regular grid, decode back to standard .vdb.

Start a pilot with your data See how it works
Source render of a smoke plumeThe same smoke frame at Q50
Source · 4.0 GBQ50 · 341 MB
Drag to compare · inspect all renders

How a read works

What happens when a renderer asks for one voxel?

A VQField file doesn't have to be unpacked before anything can read it. The field stays compressed in memory. A request finds the 8³ block that holds the voxel, decodes that block and keeps it in a cache whose size you choose.

Tools that expect a regular grid take the other path: decode every block once and write a standard .vdb.

Runtime readKarma CPU, the SDK, your renderer
  1. .vqfield in memorystays compressed
  2. one 8³ block decoded512 values
  3. block cachesize set by you
  4. Karma CPU
    SDK
    your renderer
    the callerreceives values
Full decodefor tools that need a regular grid
  1. .vqfield file
  2. decode every block
  3. standard .vdb
  4. any OpenVDB tool
42.5ms

Prepare the sampler, once per file.

66ns

First sample in an uncached block, in this benchmark.

~9ns

Subsequent cached samples, approximately.

Try it

Point at the smoke. The renderer’s ray reads the blocks it passes through, stopping when the smoke becomes opaque. The rest stays compressed.

A render camera’s ray crosses the blocks of a smoke volume.A camera ray crosses a sparse smoke volume. Blocks along the ray enter a simulated cache.
Block-read illustrationPoint to cast · drag to turn

Interactive illustration loads as you reach it

This ray reads
0 blocks
Unique blocks decoded
0 of —
Never decoded
— blocks
Block cache
0 /
Cache hit rate
—

What it's for

What a VQField cache lets you do

Every figure below comes from the published test sequence. Your data will land somewhere else on the curve, which is why a pilot starts with it.

Six ways to use a VQField cacheSwipe or use ← →

SOURCE4.0 GBQ701.03 GBQ50341 MBQ3037 MB

Keep every version on disk

Archive wedges and iterations instead of deleting them. The same 166 frames at three settings, drawn to scale against the source.

SOURCE32.1 sQ502.7 sat 1 Gb/s · ideal link

Move less data between machines

Ideal transfer time for the sequence over a 1 Gb/s link. Less to sync to the farm, to the cloud or to another site.

■ decoded□ crossed, empty: skipped

Render without unpacking

In Houdini, Karma CPU reads the compressed field through the VQField sampler and decodes only the blocks its rays touch.

GOP 1GOP 2IIseek to frame 13: replay the block from frame 8

Seek through long sequences

A seek replays the requested block from its nearest INTRA frame, within one group of pictures. Access stays bounded by the GOP, however long the sequence is.

ONE RATE-CONTROL MODE PER ENCODEQuality50Target PSNRdBTarget ratiox : 1

Check quality before you commit

Encode by quality, target PSNR or target ratio. Use Studio reports to inspect sizes and supported error metrics, then validate the renders for your workflow.

C ABI · C++ HELPERS · OPAQUE HANDLESyour appVQField SDKvaluespoints · blocks · batches

Build it into your own tools

A C ABI with C++ helpers: open a file, prepare a sampler and read points, blocks or batches. No OpenVDB types cross the boundary.

Integrations

Where it plugs in

One engine behind three surfaces. Houdini, Studio and the SDK share the codec and file format, with different workflows around them.

Houdini · Studio CLI · SDKSwipe or use ← →

Pyro solverVQField encodesmoke.vqfieldKarma CPUquality 50 · GOP 8
Illustrationworkflow schematic

Houdini

Encode and decode grids and sequences with nodes; Karma CPU reads compressed fields through the sampler. Current beta packages target specific Windows x64 Houdini builds.

Karma CPU · Houdini workflow
Studio CLI
$ vqfield encode input.vdb -o output.vqfield --quality 50
$ vqfield decode output.vqfield -o reconstructed.vdb
$ vqfield encode-sequence "sim.%04d.vdb" --range 1001:1100 -o sim.vqfield --quality 50 --gop 8
$ vqfield inspect sim.vqfield --json

Studio CLI

Headless commands for scripts: encode, decode, encode-sequence, decode-sequence, inspect, benchmark and report. Inspect and benchmark support JSON output; reports can include JSON artifacts.

Command reference
C ABI
Public sampling APIvqfield_open_vqvdbvqfield_sampler_createvqfield_sample_componentsRead the API and lifetime rules

SDK

A C ABI with opaque handles and C++ helpers. Point, block and batch sampling; full-grid reconstruction through the C++ codec and OpenVDB adapter.

C ABI · C++ helpers · SDK guide
Files
.vqfield, volumes and sequences
Grids
Scalar and vector fields; validate your data in a pilot
Back to OpenVDB
Full decode to standard .vdb
Houdini beta
Windows x64 · exact builds
GPU
Not required · Karma CPU, not XPU
Your data
Runs locally on your machines

Measured

What we've measured, and how

A compression ratio means nothing without its denominator, and a latency means nothing without its phase. These are the rules every number on this site follows.

  1. Every ratio names its denominator: file bytes, or active FP32 bytes.
  2. Phases are timed apart: preparation, first access and cached access are never merged.
  3. Host, build and commit stay attached to the available benchmark evidence.
  4. Public, private and synthetic data are labelled separately.

One published test sequence

166 frames · 4,010,450,094 source bytes · whole-sequence sizes
SettingSize on diskRatioTo scale
Source4.0 GB1 : 1
Q701.03 GB3.9 : 1
Q50341 MB11.8 : 1
Q3037 MB109.4 : 1
Q209 MB447.3 : 1

Same setting, different data

quality 50 in every row · ratios move with the data and denominator
DataDenominatorRatio
166-frame smoke sequence · publishedfile bytes11.8 : 1
Production file with 4 grids · privatefile bytes14.81 : 1
256³ scalar field, 4,915 active blocks · syntheticactive FP32 bytes56.42 : 1

About

Who builds VQField

VQField is built by Enzo Crema. It is a runtime and file format for compressed fields that stay addressable: a renderer reads the blocks it touches instead of rebuilding the whole volume.

It grew out of VQVDB, the open-source research project presented at Houdini HIVE AI 2025. VQField uses a deterministic block-transform codec, with random access in space and time, a C SDK, a CLI and Houdini integration.

contact@vqfield.comHIVE AI 2025 talk (VQVDB)

Pilot

Try it on your own caches

Quality depends on the data, so we don't ask you to trust our sequence. A pilot evaluates VQField on yours, on your machines.

  1. 01

    Tell us what to test

    Grids, frame counts, Houdini version and what you want to improve: storage, transfer, render memory or scrubbing.

  2. 02

    Agree the evaluation

    Confirm your platform, the right private build and data-handling terms. Nothing has to be uploaded.

  3. 03

    Run it on your shots

    Encode at a few settings and render the way you already do.

  4. 04

    Review the results together

    Sizes, supported error metrics and renders, with timings from your hardware.