CubeComposer 4K 360° Video

CubeComposer (CVPR 2026) is a spatio-temporal autoregressive diffusion model that generates native 4K 360° panoramic video from standard perspective video input. Built on the Wan video foundation model, trained on 11,832 high-resolution clips. This is the first open model capable of native 4K 360° generation — enabling VR content creation, virtual tours, and immersive media on consumer GPU hardware.

Why This Matters

360° video has traditionally required specialized capture rigs (multiple cameras, stitching software, expensive post-processing). CubeComposer changes this:

• Input: any standard camera video (single-lens, phone camera, dashcam)

• Output: native 4K 360° equirectangular video

• Method: decomposes panoramas into cubemap faces, generates each face autoregressively with spatial consistency

• Quality: significantly outperforms previous stitching and outpainting approaches

Hardware Requirements

Config	VRAM	Resolution	Speed
RTX 4090 24GB	24GB	4K 360° (30 frames)	~8 min/clip
RTX 5090 32GB	32GB	4K 360° (60 frames)	~6 min/clip
2× RTX 4090	48GB	4K 360° (120 frames)	~9 min/clip
A100 80GB	80GB	4K 360° (240 frames)	~12 min/clip

Minimum: RTX 4090 24GB (or equivalent 24GB+ VRAM GPU)

On Clore.ai: RTX 4090 from ~$1.20/hr spot — a 2-minute clip costs ~$0.40.

Installation

# Clone repository
git clone https://github.com/TencentARC/CubeComposer
cd cubecomposer

# Install dependencies (Python 3.10+, CUDA 12.1+)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
pip install -r requirements.txt

# Download model weights (~18GB)
python scripts/download_weights.py --model cubecomposer-4k-v1

Docker (Recommended for Clore.ai)

# No official Docker image — install from source:
git clone https://github.com/TencentARC/CubeComposer /workspace/CubeComposer
cd /workspace/CubeComposer
pip install -r requirements.txt
python app.py --share --listen 0.0.0.0 --port 7860

Quick Start

CLI: Perspective Video → 4K 360°

# Basic usage: input perspective video, output 4K equirectangular
python generate_360.py \
  --input /workspace/input_video.mp4 \
  --output /workspace/output_360.mp4 \
  --resolution 4096x2048 \
  --frames 30 \
  --fps 30

# Higher quality: more steps, longer clip
python generate_360.py \
  --input /workspace/walk_through_park.mp4 \
  --output /workspace/park_360_4k.mp4 \
  --resolution 4096x2048 \
  --frames 60 \
  --num_inference_steps 50 \
  --guidance_scale 7.5 \
  --fps 30

Python API

from cubecomposer import CubeComposerPipeline
import torch

# Load pipeline
pipe = CubeComposerPipeline.from_pretrained(
    "cubecomposer/cubecomposer-4k-v1",
    torch_dtype=torch.bfloat16
).to("cuda")

# Generate 360° video from perspective input
output = pipe(
    input_video_path="input.mp4",
    num_frames=30,
    resolution=(4096, 2048),  # 4K equirectangular
    num_inference_steps=50,
    guidance_scale=7.5,
    cubemap_size=1024  # size of each cubemap face
)

# Save as standard equirectangular MP4
output.save("output_360.mp4", fps=30)
print(f"Generated 4K 360° video: output_360.mp4")

Gradio WebUI

import gradio as gr
from cubecomposer import CubeComposerPipeline
import torch

pipe = CubeComposerPipeline.from_pretrained(
    "cubecomposer/cubecomposer-4k-v1",
    torch_dtype=torch.bfloat16
).to("cuda")

def generate_360(video, frames, steps):
    output = pipe(
        input_video_path=video,
        num_frames=int(frames),
        resolution=(4096, 2048),
        num_inference_steps=int(steps)
    )
    output.save("/tmp/output_360.mp4", fps=30)
    return "/tmp/output_360.mp4"

demo = gr.Interface(
    fn=generate_360,
    inputs=[
        gr.Video(label="Input Perspective Video"),
        gr.Slider(10, 120, value=30, label="Number of Frames"),
        gr.Slider(20, 80, value=50, label="Inference Steps (quality)")
    ],
    outputs=gr.Video(label="4K 360° Output"),
    title="CubeComposer — 4K 360° Video Generation",
    description="Upload any perspective video → get native 4K 360° panoramic video"
)

demo.launch(server_name="0.0.0.0", server_port=7860, share=True)

Deploy on Clore.ai: Step-by-Step

1. Rent an RTX 4090

1. Go to clore.ai/marketplace

2. Filter: GPU with 24GB+ VRAM (RTX 4090 recommended)

3. Spot price: ~$1.20–2.50/hr depending on availability

4. Select Custom Docker or Ubuntu image

2. Setup via SSH

# Connect to your Clore server
ssh root@<server-ip>

# One-liner setup
git clone https://github.com/TencentARC/CubeComposer && \
  cd cubecomposer && \
  pip install -r requirements.txt && \
  python scripts/download_weights.py && \
  python app.py --port 7860 --host 0.0.0.0

3. Access the UI

Open http://<server-ip>:7860 in your browser to use the Gradio interface.

Workflow: Phone Video → VR-Ready 4K 360°

# Step 1: Upload phone video to server
scp ~/my_video.mp4 root@<server-ip>:/workspace/

# Step 2: Generate 4K 360° version
ssh root@<server-ip> "cd cubecomposer && python generate_360.py \
  --input /workspace/my_video.mp4 \
  --output /workspace/my_video_360_4k.mp4 \
  --resolution 4096x2048 --frames 60"

# Step 3: Add 360° metadata for YouTube/VR headsets
ffmpeg -i my_video_360_4k.mp4 \
  -c copy \
  -metadata:s:v:0 spherical=equirectangular \
  my_video_360_4k_vr.mp4

# Step 4: Download result
scp root@<server-ip>:/workspace/my_video_360_4k_vr.mp4 ~/

Spectrum Integration: 4.79× Speedup on Wan2.1

The Spectrum accelerator (CVPR 2026) — a training-free spectral diffusion feature forecaster using Chebyshev polynomials — can be applied to CubeComposer's underlying Wan2.1 base for significant speedups:

from cubecomposer import CubeComposerPipeline
from spectrum_accelerator import SpectrumAccelerator
import torch

pipe = CubeComposerPipeline.from_pretrained(
    "cubecomposer/cubecomposer-4k-v1",
    torch_dtype=torch.bfloat16
).to("cuda")

# Apply Spectrum for 4.79× speedup with no quality loss
accelerator = SpectrumAccelerator(pipe.unet, order=8)  # Chebyshev order
pipe.unet = accelerator

# Now generates at ~4.79× the original speed
output = pipe(
    input_video_path="input.mp4",
    num_frames=30,
    resolution=(4096, 2048),
    num_inference_steps=50  # Effective quality of ~240 steps
)
output.save("output_fast_360.mp4")

Quality Tips

1. Input video quality matters — higher resolution input = better 360° output

2. Stable footage — handheld shake reduces consistency across cubemap faces

3. Good lighting — avoid extreme contrast (overexposed sky + dark interior)

4. Longer clips — 30+ frames gives better temporal consistency

5. Face resolution — --cubemap_size 1024 is the sweet spot (2048 for critical work, costs 4× more VRAM)

Use Cases

• VR content creation — convert any footage for Meta Quest, Apple Vision Pro

• Virtual property tours — turn walkthrough videos into 360° tours

• Travel content — share immersive travel experiences

• Architecture visualization — 360° interior/exterior walkthroughs

• Event documentation — convert event recordings to immersive replays

• Gaming assets — generate 360° environment references

Cost Estimate for Production Workflow

Task	Clore.ai Cost
5-second clip (30 frames, 4K)	~$0.30 (RTX 4090 spot)
10-second clip (60 frames, 4K)	~$0.50
30-second clip (180 frames, 4K)	~$1.20
Batch: 100 clips (5s each)	~$30

Related Guides

• Wan2.1 Video Generation — the foundation model under CubeComposer

• FramePack — efficient long video generation (6GB VRAM!)

• LTX-2 Video — fast latent video generation

• ComfyUI — node-based workflow for video + image

• RIFE Video Interpolation — smooth out generated video

---

Last updated: March 16, 2026 | Paper: arXiv:2603.04291 (CVPR 2026) | Based on Wan2.1 foundation model