Blame for README.md

---
license: other
license_name: apache-2.0-and-cc-by-nc-sa-4.0
license_link: https://github.com/statite-ai/SpecAR#license
pipeline_tag: text-to-video
tags:
- video-generation
- autoregressive
- speculative-decoding
- inference-acceleration
- training-free
- text-to-video
- image-to-video
- video-to-video
- krea
- helios
- comfyui
base_model:
- krea/krea-realtime-video
- gdhe17/Self-Forcing
- BestWishYsh/Helios-Base
- BestWishYsh/Helios-Distilled
---

# SpecAR: Distributed Target Blocks for Fast Autoregressive Video Generation

**Up to 10.54× faster autoregressive video generation, without retraining or auxiliary reward models.**

SpecAR is a training-free inference method for accelerating autoregressive video generation. Instead of invoking a large target model for every video block, SpecAR assigns most blocks to a smaller drafter and distributes a limited number of target-generated blocks evenly across the video.

This eliminates online perceptual routing and its associated scoring overhead, while controlling the longest uninterrupted sequence of drafted blocks.

SpecAR supports **text-to-video, image-to-video, and video-to-video generation** on Krea Realtime 14B, with a single implementation supporting NVIDIA Hopper and Blackwell GPUs.

**[Project Page](https://statite.ai/specar) · [Paper](https://statite.ai/specar/specar.pdf) · [GitHub](https://github.com/statite-ai/SpecAR) · [ComfyUI](https://github.com/statite-ai/ComfyUI-SpecAR)**

![SpecAR speed comparison on Krea Realtime 14B](https://raw.githubusercontent.com/statite-ai/SpecAR/main/assets/race.webp)

*Generation comparison on Krea Realtime 14B using one NVIDIA H100. The methods generate the same video duration from the same prompt and seed. Reported latencies come from the paper's evaluation.*

## Performance

### H100: Published evaluation

SpecAR was evaluated on Krea Realtime 14B and Helios 14B using a single NVIDIA H100 80GB per model pair.

| Model | Speedup over target-only | GPU |
|---|---:|---|
| Krea Realtime 14B | **Up to 2.67×** | 1× H100 |
| Helios-Base 14B | **Up to 10.54×** | 1× H100 |

For Krea Realtime 14B, generating a 26.6-second video:

| Method | Mean latency | Speedup |
|---|---:|---:|
| Target-only | 87.6 s | 1.00× |
| SDVG, operating point for k=2 | 56.8 s | 1.54× |
| **SpecAR, k=2** | **32.8 s** | **2.67×** |
| SpecAR, k=5 | 39.0 s | 2.25× |
| SpecAR, k=7 | 42.9 s | 2.04× |

These results use 36-block rollouts at 832×480 resolution, BF16 precision, five denoising steps and FlashAttention-3.

At k=7, SpecAR retains **99.7% of target-only Restricted VBench Quality-6**, while generating 2.04× faster than target-only inference.

Across the evaluated operating points on Krea Realtime and Helios, SpecAR also achieves lower latency and matching or higher measured VisionReward and Restricted VBench Quality-6 than SDVG.

### B200: Blackwell execution

The same SpecAR Krea implementation supports NVIDIA B200 GPUs through automatic FlashAttention-4 selection. No separate Blackwell implementation or model conversion is required.

In an engineering validation using a 26.6-second coral-reef generation at k=7:

| GPU | Attention backend | Reported generation time |
|---|---|---:|
| NVIDIA H100 | FlashAttention-3 | 37.9 s |
| **NVIDIA B200** | **FlashAttention-4** | **25.8 s** |

The B200 run completed the 26.6-second video in less than its playback duration.

*These are single-video engineering measurements, not the mean end-to-end results from the paper. They do not establish a B200 speedup over Krea's optimized target-only B200 implementation. Hardware, kernel and workload settings affect the results.*

## Supported models

SpecAR uses existing publicly released model weights. **No training or new checkpoint is required.**

| Backbone | Target | Drafter |
|---|---|---|
| `krea` | [Krea Realtime 14B](https://huggingface.co/krea/krea-realtime-video) | [Self-Forcing 1.3B DMD](https://huggingface.co/gdhe17/Self-Forcing) |
| `helios` | [Helios-Base 14B](https://huggingface.co/BestWishYsh/Helios-Base) | [Helios-Distilled 14B](https://huggingface.co/BestWishYsh/Helios-Distilled) |

### Hardware compatibility

| GPU | Krea | Helios | Attention |
|---|---|---|---|
| H100 | Supported | Supported | FA3 |
| H200 | Supported | Supported | FA3 |
| B200 | Supported | Not yet supported | FA4 |

SpecAR automatically selects a compatible attention backend on supported hardware. The inference algorithm, installation procedure and CLI remain the same across Hopper and Blackwell.

## Installation

Requires Linux, Python 3.11, a compatible NVIDIA GPU and a CUDA 12.8-compatible driver.

### Krea Realtime 14B

```bash
git clone https://github.com/statite-ai/SpecAR
cd SpecAR

python3.11 -m venv .venv-krea
source .venv-krea/bin/activate

pip install ".[krea]"
specar download --backbone krea
```

The Krea setup downloads approximately 50 GB of public model files, including the Krea Realtime 14B target, Self-Forcing 1.3B drafter, text encoder and VAE.

The same installation works on H100 and B200. SpecAR automatically uses FA3 on Hopper and FA4 on Blackwell.

On shared GPU machines, running `hf auth login` before downloading can help avoid anonymous Hugging Face rate limits.

## Generate with SpecAR

### 1. Text-to-video

Generate video directly from a text prompt.

```bash
specar generate --backbone krea \
  --prompt "A papercraft coral reef full of colorful fish" \
  --k 2 \
  --out reef.mp4
```

By default, SpecAR generates 36 blocks, producing approximately 26.6 seconds of video at 16 FPS.

### 2. Image-to-video

Generate a video conditioned on an input image.

```bash
specar generate --backbone krea \
  --image photo.jpg \
  --prompt "A cinematic mountain landscape at sunrise" \
  --k 7 \
  --out video.mp4
```

The image is resized to the model's 832×480 resolution and used as the initial visual context.

### 3. Video-to-video

Generate a video conditioned on an existing clip.

```bash
specar generate --backbone krea \
  --video input.mp4 \
  --prompt "A futuristic city at night" \
  --strength 0.8 \
  --k 7 \
  --out transformed.mp4
```

The `--strength` parameter controls the degree of transformation relative to the input video. The source video's duration limits the output length.

### Generation controls

| Parameter | Description |
|---|---|
| `--k` | Number of blocks generated by the target |
| `--blocks` | Total autoregressive blocks |
| `--seconds` | Requested video duration |
| `--seed` | Random seed |
| `--steps` | Krea denoising steps per block |
| `--attention` | `auto`, `fa2`, `fa3`, or `fa4` |
| `--image` | Initial image for image-to-video |
| `--video` | Input clip for video-to-video |
| `--strength` | Video-to-video transformation strength |
| `--save-latents` | Save generated latent tensors |

The default target budget is k=7. Lower values generally favor speed, while increasing the target budget changes the quality–latency trade-off.

For all options and sample outputs, see the [SpecAR GitHub repository](https://github.com/statite-ai/SpecAR).

## ComfyUI

SpecAR is also available as a ComfyUI custom-node integration for Krea Realtime 14B.

**[ComfyUI-SpecAR — Installation, Nodes and Workflows](https://github.com/statite-ai/ComfyUI-SpecAR)**

The ComfyUI integration uses the same SpecAR inference engine rather than a separate implementation of the decoding algorithm.

See the custom-node repository for its installation requirements and supported workflows.

## How it works

SpecAR treats the placement of expensive target-model executions as a scheduling problem.

Given a video of H autoregressive blocks and a target budget k, it selects target positions according to

$$
\mathcal{A}_k =
\left\{
\left\lfloor \frac{jH}{k}+\frac{1}{2}\right\rfloor
\;\middle|\;
j=0,\ldots,k-1
\right\}.
$$

The target generates the blocks at these positions. The drafter generates all remaining blocks.

The resulting schedule minimizes the longest uninterrupted draft run for the specified target budget, with the first block assigned to the target.

Unlike online perceptual routing, SpecAR requires:

- No additional training.
- No learned router or reward model.
- No per-block perceptual scoring.
- No discarded draft candidate at a predetermined target position.

Both models operate on the same committed video trajectory. Model-specific KV caches are reconstructed from the committed context as required.

SpecAR is an approximate decoder: the scheduling guarantee does not guarantee identical target-model outputs or preservation of the target distribution.

## Reproducibility

The repository provides benchmark commands and reference latent hashes for reproducing the original H100 experiments.

```bash
specar-benchmark --backbone krea --weights weights
```

On the reference Hopper configuration with FlashAttention-3 and five denoising steps, the benchmark checks generated latents against the published SHA-256 hashes.

Different attention kernels and GPU architectures can produce numerically different outputs. On other supported configurations, the benchmark records execution times and output hashes without requiring bitwise identity with the H100 reference.

See the [repository documentation](https://github.com/statite-ai/SpecAR) for pinned dependencies, benchmark settings and Helios setup.

## Citation

```bibtex
@misc{hassan2026specar,
  title  = {SpecAR: Distributed Target Blocks for Fast Autoregressive Video Generation},
  author = {Hassan, Hudeifa},
  year   = {2026},
  note   = {Preprint},
  url    = {https://statite.ai/specar}
}
```

## License

SpecAR's original scheduling, inference utilities, CLI and benchmarking code are distributed under **Apache-2.0**.

The Krea Realtime backend incorporates code adapted from Krea's inference implementation and retains **CC BY-NC-SA 4.0** licensing, restricting commercial use. Vendored Helios components retain their respective Apache-2.0 terms.

Model weights are not redistributed. Each checkpoint remains governed by its original license.

See [LICENSE and file-level notices](https://github.com/statite-ai/SpecAR#license).

---

Developed by **[Statite](https://statite.ai)**.

[Project Page](https://statite.ai/specar) · [Paper](https://statite.ai/specar/specar.pdf) · [Source Code](https://github.com/statite-ai/SpecAR) · [ComfyUI](https://github.com/statite-ai/ComfyUI-SpecAR)