Use an RVC cast

Install the three CLI pieces

These commands install the smpl frame tools, the light vox dispatcher, and the light vox-cast frontend. They do not install an RVC model or download a person's voice.

$ uv tool install git+https://github.com/chronick/smpl#subdirectory=packages/smpl \
    --with git+https://github.com/chronick/smpl#subdirectory=packages/smplstream \
    --with git+https://github.com/chronick/smpl#subdirectory=packages/smpl-analysis
$ uv tool install git+https://github.com/chronick/vox#subdirectory=packages/vox
$ uv tool install git+https://github.com/chronick/vox#subdirectory=tools/vox-cast

Also required: uv on PATH and a network connection for the one-time setup below. Conversion itself is local after setup.

1. Set up the shared inference engine

Inspect first, then build once:

$ vox cast setup --status
$ vox cast setup

setup creates an isolated Python 3.10 RVC environment under ~/.vox/engines/rvc. The environment is about 3 GB after torch and its dependencies. Setup also downloads exactly 732,380,624 bytes (about 732 MB decimal) of shared HuBERT/RMVPE inference assets, pinned to Hugging Face commit bbb6736b97a98df0a87fe3592c0a061c53f0a75f.

Those assets recognize content and pitch for every cast; they are not a trained person's voice. A cast remains a separate .pth file that you must obtain lawfully and import yourself. The Python stack installs from a checked-in, hash-verified dependency lock rather than resolving new transitive versions during setup. Set VOX_RVC_ENGINE to move the engine; use vox cast setup --fresh only when intentionally rebuilding it.

2. Inspect provenance before import

Prefer a self-trained, explicitly licensed, or fully synthetic model. Before loading any .pth, verify its source and checksum and read its model card and license. RVC weights are pickle-based artifacts, so treat an unknown file as executable untrusted input, not just media.

$ shasum -a 256 ~/Downloads/mycast/mycast.pth ~/Downloads/mycast/mycast.index

$ sha256sum ~/Downloads/mycast/mycast.pth ~/Downloads/mycast/mycast.index

Use the command for your system and compare every result with the publisher's SHA256SUMS.txt. A matching hash proves which bytes you received; it does not prove that the model was created or licensed ethically.

A normal export has one required weights file and an optional retrieval index. A directory may also include training metadata:

mycast/
├── mycast.pth          # required weights
├── mycast.index        # optional retrieval bank
├── config.json         # optional training sidecar
├── model_info.json     # optional training sidecar
├── MODEL_CARD.md       # source, consent, intended use, limitations
├── LICENSE.md          # permission and restrictions
└── SHA256SUMS.txt      # release checksums

No first-party cast is claimed or downloaded by this guide. Training is outside vox; Applio and other RVC trainers can produce a standard RVC v2 export (use --arch v1 only for a v1 model).

3. Import and identify the cast

Import either a model directory or a .pth. The optional --index selects a retrieval bank, and --name chooses the stable local name. Import copies the weights, selected index, and common JSON/YAML/text/image/Markdown sidecars into ~/.vox/casts (or VOX_CASTS_DIR) and refuses to overwrite an existing cast.

$ vox cast import --model ~/Downloads/mycast --name mycast

# Or import explicit files:
$ vox cast import --model ~/Downloads/mycast.pth \
    --index ~/Downloads/mycast.index --name mycast

$ vox cast list
$ vox cast info --model mycast

list inventories the local library. info reads the chosen files and available metadata without loading torch. Import and info receipts include exact SHA-256 values for the weights/index plus the copied sidecar inventory. Confirm those hashes, paths, architecture notes, and sample rate against the publisher's release receipt before conversion.

4. Convert a take

The smpl pipe keeps the dry frame and adds a converted voice.wet frame with model name and every conversion knob in params:

$ smpl read take.wav | vox cast convert --model mycast --trust-model | smpl write voiced.wav

--trust-model explicitly acknowledges that pickle-based .pth weights can execute Python code. The engine venv keeps dependencies separate; it is not a security sandbox. Use the flag only after verifying the publisher and exact checksum.

For a direct input file, keep smpl write on the end so the protocol output becomes a WAV:

$ vox cast convert --in take.wav --model mycast --trust-model \
    --pitch 0 --index-rate 0.5 | smpl write voiced.wav

Start with cpu:0 for the deterministic path. Adjust pitch only when source and model ranges need it; increase --index-rate carefully because stronger retrieval can trade room and diction for more model timbre. Keep the dry input beside the wet output for review.

5. Compare before you keep it

Listen dry against wet for intelligibility, pitch stability, consonant damage, breath artifacts, and whether the performance still feels like the source. For a measured comparison, add the analysis tools:

$ uv tool install git+https://github.com/chronick/vox#subdirectory=tools/vox-ear
$ uv tool install git+https://github.com/chronick/vox#subdirectory=tools/vox-vector

$ smpl read take.wav | vox ear describe | vox vector measure | smpl view
$ smpl read voiced.wav | vox ear describe | vox vector measure | smpl view

Use the measurements as evidence about the render, not as proof of identity or authorization. Final judgment belongs to the performer or producer who can hear the words and context.

Publishing a redistributable first-party cast

If a project later creates a cast it has the right to redistribute, publish each version as a GitHub Release asset, not in Git and not through Git LFS. A release bundle should contain the .pth, optional .index, model card, license, and checksums. The model card should name the dataset source and consent, training tool and RVC architecture, intended and prohibited uses, known limitations, and a contact for rights questions.

Publishing mechanics do not create permission. Verify consent and redistribution rights before release, and never describe a cast as available until its release and checksums actually exist.