Skip to main content
Helios is an interactive, real-time video generation model built on a 14B-parameter Diffusion Transformer. It produces a continuous, infinite video stream that you steer in real time: change prompts, swap reference images, and control playback while the video keeps playing. The Helios reference is split across four pages: this overview, the complete command and event schema, the prompt guide for writing prompts that produce smooth output, and an end-to-end tutorial against the open-source reference frontend. The base wire protocol is the same as every other Reactor model: open a session with the Reactor class (model name helios), send named commands, receive events. Helios’s surface adds a small set of model-specific commands for prompts, reference images, the seed, and playback control.

​
At a glance

SpecValue
Model namehelios
Pricing
Chunk size33 frames
Super-resolutionoff · 2x · 4x
The model name is the string you pass when you open a session, e.g. new Reactor({ modelName: "helios" }). See Pricing & Billing for how billing works.

​
Key features

Autoregressive streaming

Continuous, infinite video stream with smooth temporal coherence across minutes of generation.

Image-to-video

Provide a reference image to guide generation and swap it mid-stream.

Real-time prompt control

Schedule prompt changes at specific points during generation for dynamic scene transitions.

​
Quick start

The fastest path to a working Helios app is the create-reactor-app CLI, which scaffolds a runnable project for you. You can also clone the open-source reference frontend directly, or follow the tutorial for a guided walkthrough. 
npx create-reactor-app my-helios-app --model=helios
Working in Python instead? The CLI is JavaScript-only, so install the SDK with pip install reactor-sdk and follow the Python tab below (see the quickstart for the full walkthrough). A minimal connect-and-generate flow looks like: 
import { Reactor } from "@reactor-team/js-sdk";

const video = document.querySelector("video")!;
const reactor = new Reactor({ modelName: "helios" });

// Render frames as soon as they arrive.
reactor.on("trackReceived", (name, track, stream) => {
  if (name !== "main_video") return;
  video.srcObject = stream;
  void video.play();
});

// Once the session is ready, set a prompt and start generating.
reactor.on("statusChanged", async (status) => {
  if (status !== "ready") return;
  await reactor.sendCommand("set_prompt", { prompt: "A serene mountain landscape at sunrise" });
  await reactor.sendCommand("start", {});
});

const jwt = await getToken(); // token minted on your server
await reactor.connect(jwt);

import asyncio
import os
from reactor_sdk import Reactor, ReactorStatus

async def main():
    reactor = Reactor(model_name="helios", api_key=os.environ["REACTOR_API_KEY"])

    # Frames arrive as (H, W, 3) uint8 RGB NumPy arrays.
    @reactor.on_frame
    def on_frame(frame):
        print(f"Frame: {frame.shape}")

    # Once the session is ready, set a prompt and start generating.
    @reactor.on_status(ReactorStatus.READY)
    async def on_ready(status):
        await reactor.send_command("set_prompt", {"prompt": "A serene mountain landscape at sunrise"})
        await reactor.send_command("start", {})

    await reactor.connect()
    await asyncio.Event().wait()  # run until interrupted

asyncio.run(main())
That uses the base SDK. Helios also has a typed SDK, @reactor-models/helios, with named methods (setPrompt, start, …) and React hooks; the tutorial uses it. See Typed Model SDKs.

​
How it works

When you connect to Helios, the model is active and ready but won’t start generating until you explicitly tell it to. The workflow:
  1. Connect to the model.
  2. Set a prompt with set_prompt or schedule_prompt at chunk 0 (required).
  3. Optionally upload and set a reference image for image-to-video mode.
  4. Start generation.
  5. Control playback with pause / resume.
  6. Schedule additional prompts at future chunks, or reset to start over.
  7. Change the reference image mid-generation. The reference image is cleared on reset.
Helios generates video in short segments called chunks, each 33 frames long. You can send commands at any time, but they take effect at the start of the next chunk. There can be a short delay between sending a command and seeing the change in the video.