Model reference · open weights

Bernini-R

Video ByteDance Image→video 3 builds Open weights 118 dl/mo

Bernini-R is an open-weight video model from ByteDance. Bernini-R (BF16) weighs 168 GB; the smallest configuration that runs it is RTX PRO 6000 Blackwell 96 GB.

  • Bernini-R is an image-text-to-video model developed by ByteDance that functions as the renderer within the Bernini framework, which combines an MLLM-based semantic planner with a DiT-based renderer.
  • The model supports various tasks including text-to-video, video editing, and reference-to-video generation, with default inference outputs at 480p resolution and 16fps.
  • It is released under the Apache-2.0 license and requires a CUDA GPU environment for operation.

Summary of the ByteDance/Bernini-R model card, 2026-10-01

What it is

Released byByteDance
Released2026-06-01
VRAM168 GB for the weights

What it runs on

Memory and cards for Bernini-R (BF16)

168 GBweights, file size
84.1 GBbiggest part
537 MBruntime overhead
CardWeightsMemory
RTX 3060 12 GB … H100 80 GBdoes not fit
RTX PRO 6000 Blackwell 96 GBtight (encoders offloaded)93.8 GB
DGX Spark (GB10) 128 GB unifiedfits (encoders offloaded)107 GB
H200 141 GBfits (encoders offloaded)138 GB
B200 180 GBtight176 GB

Builds

Sizes, precisions & builds

BuildParamsPrecisionWeightsSmallest setup
Bernini-R (above) ↗ —BF16 168 GBRTX PRO 6000 Blackwell 96 GB
Bernini-R-1.3B-Diffusers ↗ 1.4BFP32 14.5 GBRTX 4060 Ti 16 GB
Bernini-R-Diffusers ↗ 14.3BFP32 63.1 GBRTX 5090 32 GB

From the model card

What ByteDance says about Bernini-R

Read the model card

Chenchen Liu*, Junyi Chen*, Lei Li*, Lu Chi*,§, Mingzhen Sun*, Zhuoying Li*, Yi Fu, Ruoyu Guo, Yiheng Wu, Ge Bai, Zehuan Yuan✉

🎉 News

✨ Highlights

Bernini is a unified framework for video generation and editing that combines an MLLM-based semantic planner with a DiT-based renderer.

On video editing, Bernini reaches the first tier among leading closed-source commercial models. The leaderboard below comes from our self-built arena platform, where human annotators blindly vote on paired edits and the votes are aggregated into a Bradley-Terry score and a pairwise win-rate matrix.

📦 Installation

Requirements

  • Python 3.11.2.
  • CUDA GPU — a Hopper GPU (H100/H800/H200) is recommended so FlashAttention-3 can be used; other CUDA GPUs fall back to FlashAttention-2 or PyTorch SDPA.
  • CUDA toolkit 12.4 (matches the pinned torch==2.5.1+cu124; 12.3+ is the minimum if you build FlashAttention-3).
  • Pinned in requirements.txt: torch==2.5.1+cu124, diffusers==0.35.2, accelerate==0.34.2, transformers==4.57.3.

Reference environment (Bernini-R is developed and tested on this setup):

ComponentVersion
GPUNVIDIA H100
CUDA12.4
Python3.11.2
PyTorch2.5.1+cu124

Install

git clone https://github.com/bytedance/Bernini.git bernini && cd bernini
pip install -r requirements.txt

Optional extras:

  • Multi-GPU sequence parallel needs Open-VeOmni (Apache-2.0, Python 3.11). Use --no-deps so VeOmni does not pull in a different torch build and override the pinned torch==2.5.1+cu124: pip install --no-deps git+https://github.com/ByteDance-Seed/VeOmni.git@v0.1.10. Single-GPU inference does not need it.
  • Faster attention (auto-detected if installed; otherwise PyTorch SDPA is used):
    • FlashAttention-2 — general CUDA GPUs (incl. A100/A800): pip install flash-attn==2.8.3.
    • FlashAttention-3 — Hopper only (H100/H800/H200, CUDA ≥ 12.3, PyTorch ≥ 2.4). flash_attn_interface is not on PyPI; build it from the flash-attention repo's hopper/ directory at tag v2.8.3:
      git clone https://github.com/Dao-AILab/flash-attention.git
      cd flash-attention && git checkout v2.8.3
      cd hopper && MAX_JOBS=$(nproc) python3 setup.py install --user
      

Weights

Bernini-R provides two ways to obtain the renderer weights. The diffusers format is recommended — it is a self-contained diffusers-format directory whose transformer / transformer_2 already hold the Bernini-R weights, so you point --config at it and the weights load directly, with no --high_noise_ckpt / --low_noise_ckpt needed.

Option A — diffusers format (recommended)

A single ready-to-use diffusers-format model from ByteDance/Bernini-R-Diffusers. It bundles the Wan2.2 base components (VAE, UMT5 text encoder, tokenizer) together with the Bernini-R transformer weights, so nothing else is downloaded at runtime.

pip install -U "huggingface_hub"
hf download ByteDance/Bernini-R-Diffusers --local-dir Bernini-R-Diffusers

Then pass it via --config and omit the checkpoint flags, e.g.:

python infer_single_gpu.py --config Bernini-R-Diffusers \
    --case assets/testcases/t2i/t2i.json --num_frames 1
Option B — separate checkpoints

The original layout, where Bernini-R uses two sets of weights loaded separately:

  1. Wan2.2 base — Wan-AI/Wan2.2-T2V-A14B-Diffusers on Hugging Face. Supplies the VAE, UMT5 text encoder, tokenizer, and the transformer architecture/base weights. It is downloaded automatically on first run (configured by wan22_base in configs/bernini_renderer_wan22/config.json).
  2. Bernini-R checkpoint — the trained high-noise / low-noise transformer weights (safetensors) from ByteDance/Bernini-R, passed with --high_noise_ckpt / --low_noise_ckpt. Both a local directory and a Hugging Face repo id are accepted.

Download models using huggingface-cli:

pip install -U "huggingface_hub"
hf download Wan-AI/Wan2.2-T2V-A14B-Diffusers --local-dir Wan2.2-T2V-A14B-Diffusers
hf download ByteDance/Bernini-R --local-dir Bernini-R

🚀 Usage

A run is described by a case file — a small JSON under assets/testcases/ that bundles one task's routing and inputs (task_type, guidance_mode, prompt, source media, output). This keeps long prompts out of the command line. Each task has a directory under assets/testcases/ holding one or more case files; see assets/testcases/ for the format and the bundled t2i / i2i / t2v / v2v / rv2v /r2v examples.

Prompt enhancer (highly recommended)

--use_pe enhances the prompt through an OpenAI-compatible endpoint and is recommended for best generation quality. The openai SDK is installed by requirements.txt; configure the endpoint with environment variables:

export BERNINI_PE_API_KEY=...      # or OPENAI_API_KEY
export BERNINI_PE_BASE_URL=...     # or OPENAI_BASE_URL
export BERNINI_PE_MODEL=...        # vision-capable chat model

Examples by task type

Unless an example specifies otherwise, inference outputs 480p / 16fps (the defaults — --max_image_size 848, --fps 16).

Each example runs a bundled case in [`assets/testcase

Quoted from the model card on Hugging Face. The full card is behind the Hugging Face link above.

Running it yourself

Run it on a rented GPU

Rent a machine by the hour. ComfyUI is installed on it. Open ComfyUI through the tunnel, then Templates → Bernini-R: Video Edit: it loads ComfyUI's own build of this model, the files above.

# on your rented machine (the ssh line is on its page in the console)
# get REPO FILE FOLDER: one file into /workspace/models/FOLDER, where ComfyUI loads it from
get() { hf download "$1" "$2" --local-dir /workspace/hf-files && mkdir -p "/workspace/models/$3" && mv "/workspace/hf-files/$2" "/workspace/models/$3/$4"; }

# the files of the template “Bernini-R: Video Edit” (36.1 GB)
get Comfy-Org/Wan_2.1_ComfyUI_repackaged split_files/text_encoders/umt5_xxl_fp8_e4m3fn_scaled.safetensors text_encoders
get Kijai/WanVideo_comfy Wan2_1_VAE_bf16.safetensors vae
get Kijai/WanVideo_comfy Lightx2v/lightx2v_T2V_14B_cfg_step_distill_v2_lora_rank64_bf16.safetensors loras
get Comfy-Org/Bernini-R diffusion_models/wan2.2_bernini_r_high_noise_fp8_scaled.safetensors diffusion_models
get Comfy-Org/Bernini-R diffusion_models/wan2.2_bernini_r_low_noise_fp8_scaled.safetensors diffusion_models

start-comfyui
Renting a GPU: connect, tunnels, ComfyUI
# on your computer, in a second terminal: ComfyUI in your browser at http://localhost:8188
# HOST and PORT are your machine's, from its page in the console
ssh -L 8188:localhost:8188 dev@HOST -p PORT
© 2026 AxForge · EU-hosted AI infrastructure Pricing Docs Trust Privacy Terms