Helios

Helios is an interactive, autoregressive video generation model that produces continuous video streams in real-time. Built on a 14B-parameter Diffusion Transformer, Helios generates video in 33-frame chunks with multi-resolution history conditioning, enabling minute-scale video generation with smooth temporal coherence.

Key Features

Autoregressive Streaming

Generates video in 33-frame chunks with multi-resolution history conditioning for long-form coherence

Image-to-Video

Provide a reference image to guide generation and swap it mid-stream with cut or blend transitions

Real-Time Prompt Control

Schedule prompt changes at specific chunks during generation for dynamic scene transitions

Quick Start

Get started with Helios in seconds:

npm
pnpm

npx create-reactor-app my-helios-app helios-interactive

pnpm create reactor-app my-helios-app helios-interactive

This creates a Next.js application from our open-source example.

Model Name

helios

Prompt Guide

Getting good results from Helios depends heavily on how you write your prompts.

Be detailed and descriptive

Helios responds best to long, richly detailed prompts. Instead of short descriptions, paint a full picture: describe the scene, lighting, camera angle, atmosphere, and any objects or characters present.

Good
Too vague

A rotating camera view inside a large New York museum gallery, showcasing a towering stack of vintage televisions, each displaying different programs from the 1950s and 1970s. The televisions show a mix of 1950s sci-fi movies, horror films, news broadcasts, static, and a 1970s sitcom. The gallery space is filled with the nostalgic glow of the old TV screens, their edges worn and frames aged. The background features other vintage exhibits and artifacts, adding to the historical ambiance. The televisions are arranged in a dynamic, almost chaotic pattern, creating a sense of visual interest and movement. A wide-angle shot capturing the entire stack and the surrounding gallery space.

A desert with a camel

Prompt transitions need detail too

When updating the prompt mid-generation with set_prompt or schedule_prompt, the new prompt should be just as detailed as the original. Vague transition prompts will produce subtle or unnoticeable changes.

Good
Too vague

A rotating camera view inside a large New York museum gallery, showcasing a towering stack of vintage televisions, each displaying different programs from the 1950s and 1970s. The televisions show the text REACTOR. The gallery space is filled with the nostalgic glow of the old TV screens, their edges worn and frames aged. The background features other vintage exhibits and artifacts, adding to the historical ambiance. The televisions are arranged in a dynamic, almost chaotic pattern, creating a sense of visual interest and movement. A wide-angle shot capturing the entire stack and the surrounding gallery space.

The televisions show the text REACTOR.

Helios generates video in 33-frame chunks. Prompt changes take effect at chunk boundaries, so visual transitions are not instantaneous — there is a natural delay of one chunk before the new prompt influences the output.

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. Here’s the workflow:

Connect to the model
Set a prompt using set_prompt or schedule_prompt at chunk 0 (required)
Optionally set a reference image for image-to-video mode
Start generation
Control playback with pause/resume as needed
Schedule additional prompts at future chunks or reset to start over
Change or remove the reference image mid-generation, or adjust image strength

Helios generates video in chunks (33 frames each), not individual frames. Prompt scheduling and state tracking operate at the chunk level.

Commands

Send commands to the model using reactor.sendCommand(). Below are all available commands:

Command	Description
`set_prompt`	Set the prompt (at chunk 0, or current chunk if running)
`schedule_prompt`	Schedule a prompt at a specific chunk index
`set_image`	Set or change a reference image (works mid-generation)
`clear_image`	Remove image anchor, continue with text only
`set_seed`	Set the RNG seed for reproducible generation
`start`	Begin video generation
`pause`	Pause generation
`resume`	Resume generation
`reset`	Reset to initial state

set_prompt

Convenience wrapper around schedule_prompt that automatically picks the right chunk index so you don’t have to track it yourself:

Not started: schedules at chunk 0
Paused: schedules at the current chunk (takes effect on resume)
Running: schedules at the next chunk (current chunk is already being processed)

This is the simplest way to change the prompt — just call set_prompt and the model figures out when to apply it.Parameters:

Parameter	Type	Required	Description
`prompt`	string	Yes	The prompt text to use for generation

Example:

// Set initial prompt (before starting)
await reactor.sendCommand("set_prompt", {
  prompt: "A serene mountain landscape at sunrise"
});

// Change prompt mid-generation — automatically applies at the next chunk
await reactor.sendCommand("set_prompt", {
  prompt: "The landscape transitions to a stormy ocean"
});

schedule_prompt

Schedule a prompt to be applied at a specific chunk index during video generation.Parameters:

Parameter	Type	Required	Description
`prompt`	string	Yes	The prompt text to use
`chunk`	integer	Yes	The chunk index at which to apply the prompt

Behavior:

Scheduling a prompt at a chunk that already has a prompt will overwrite it
Prompts scheduled in the past are rejected (e.g., if the model is at chunk 10 and you schedule at chunk 5, an error is emitted)
A prompt must exist at chunk 0 before calling start
Prompts can be scheduled while generation is running for real-time control

Example:

// Schedule initial prompt (required before start)
await reactor.sendCommand("schedule_prompt", {
  prompt: "A serene mountain landscape at sunrise",
  chunk: 0
});

// Schedule a transition at chunk 10
await reactor.sendCommand("schedule_prompt", {
  prompt: "The mountain transforms into a futuristic city",
  chunk: 10
});

set_image

Set or change the reference image for image-to-video conditioning. Can be called before or during generation.Parameters:

Parameter	Type	Required	Description
`image_b64`	string	Yes	Base64-encoded reference image (RGB). Data URL prefix is stripped automatically.
`transition`	string	No	Transition mode: `"cut"` for immediate switch (default), `"blend"` for interpolation

Behavior:

Can be set before starting or while generation is running
The image is resized to match the model’s output resolution
Use transition: "blend" for a smooth interpolation to the new image, or "cut" for an immediate switch

The image_b64 payload currently has a maximum size of ~64 KB. You must resize and compress the image before sending.

Preparing an image:Use a helper like the one below to resize and JPEG-compress an image file before sending. This produces a payload well under the 64 KB limit.

/** Resize and JPEG-compress an image for set_image. */
function prepareImageForUpload(
  file: File,
  maxWidth = 640,
  maxHeight = 384,
  quality = 0.5
): Promise<string> {
  return new Promise((resolve, reject) => {
    const img = new Image();
    img.onload = () => {
      const scale = Math.min(maxWidth / img.width, maxHeight / img.height, 1);
      const w = Math.round(img.width * scale);
      const h = Math.round(img.height * scale);
      const canvas = document.createElement("canvas");
      canvas.width = w;
      canvas.height = h;
      const ctx = canvas.getContext("2d");
      if (!ctx) return reject(new Error("Failed to get canvas context"));
      ctx.drawImage(img, 0, 0, w, h);
      resolve(canvas.toDataURL("image/jpeg", quality));
    };
    img.onerror = reject;
    img.src = URL.createObjectURL(file);
  });
}

If you’re working server-side (Node.js, Python, etc.), resize the image to at most 640×384 and encode as JPEG at ~50% quality before base64-encoding. The resulting string should be well under 64 KB.

Example:

// Set initial reference image
const imageB64 = await prepareImageForUpload(imageFile);
await reactor.sendCommand("set_image", {
  image_b64: imageB64
});

// Change image mid-generation with a smooth blend
const newImageB64 = await prepareImageForUpload(newImageFile);
await reactor.sendCommand("set_image", {
  image_b64: newImageB64,
  transition: "blend"
});

clear_image

Remove the reference image anchor. Generation continues with text-only conditioning.Parameters: NoneExample:

await reactor.sendCommand("clear_image", {});

set_seed

Set the RNG seed for reproducible generation.Parameters:

Parameter	Type	Required	Description
`seed`	integer	Yes	RNG seed value

Behavior:

If generation hasn’t started, the seed takes effect immediately
If generation is running, the seed takes effect on the next reset

Example:

await reactor.sendCommand("set_seed", { seed: 42 });

start

Begin the video generation process.Parameters: NoneRequirements:

A prompt must be scheduled at chunk 0 before calling this command (via set_prompt or schedule_prompt)

Example:

await reactor.sendCommand("start", {});

pause

Pause the video generation after the current chunk finishes processing. The model retains its full state including history buffers.Parameters: NoneExample:

await reactor.sendCommand("pause", {});

resume

Resume video generation from where it was paused.Parameters: NoneExample:

await reactor.sendCommand("resume", {});

reset

Stop generation and reset the model to its initial state.Parameters: NoneEffects:

Halts any ongoing generation
Clears all scheduled prompts and history buffers
Resets the RNG generator
Returns the model to a clean state ready for new prompts

Example:

await reactor.sendCommand("reset", {});

Messages from Model

Listen for messages from the model using reactor.on("message", ...) (imperative) or the useReactorMessage() hook (React). The model emits two types of messages:

State Messages

State messages provide a snapshot of the current model state. They are emitted:

When a prompt is scheduled
When generation starts
When generation is paused or resumed
When a prompt switch occurs at a chunk boundary
When generation is reset
After each chunk is processed

{
  type: "state",
  data: {
    running: boolean,                // Whether generation is actively running
    current_frame: number,           // Global pixel frame counter
    current_chunk: number,           // Current chunk index
    current_prompt: string | null,   // Active prompt text (null if not started)
    paused: boolean,                 // Whether generation is paused
    scheduled_prompts: {             // Map of chunk indices to prompts
      [chunk: number]: string
    }
  }
}

Example handler:

reactor.on("message", (msg) => {
  if (msg.type === "state") {
    console.log(`Running: ${msg.data.running}`);
    console.log(`Frame: ${msg.data.current_frame}`);
    console.log(`Chunk: ${msg.data.current_chunk}`);
    console.log(`Prompt: ${msg.data.current_prompt}`);
    console.log(`Paused: ${msg.data.paused}`);
  }
});

Event Messages

Emitted when lifecycle events occur:

{
  type: "event",
  data: {
    event: string,  // Event type
    // Additional fields depending on event type
  }
}

Event Types

Event	Description	Additional Fields
`generation_started`	Generation has begun	`prompt: string`
`generation_paused`	Generation was paused	`frame: number`, `chunk: number`
`generation_resumed`	Generation was resumed	`frame: number`, `chunk: number`
`generation_reset`	Model was reset	`frame: number`, `chunk: number`
`image_set`	Reference image was set or changed	`width: number`, `height: number`, `transition: string`
`image_cleared`	Reference image was removed	—
`seed_set`	RNG seed was updated	`seed: number`
`prompt_scheduled`	A prompt was scheduled	`chunk: number`, `prompt: string`
`prompt_switched`	Active prompt changed at a chunk boundary	`frame`, `chunk`, `new_prompt`, `previous_prompt`
`error`	An error occurred	`message: string`

Example handler:

reactor.on("message", (msg) => {
  if (msg.type === "event") {
    switch (msg.data.event) {
      case "generation_started":
        console.log(`Generation started with prompt: ${msg.data.prompt}`);
        break;
      case "generation_reset":
        console.log(`Reset at frame ${msg.data.frame}, chunk ${msg.data.chunk}`);
        break;
      case "image_set":
        console.log(`Reference image set: ${msg.data.width}x${msg.data.height}`);
        break;
      case "seed_set":
        console.log(`Seed set to ${msg.data.seed}`);
        break;
      case "prompt_scheduled":
        console.log(`Prompt scheduled at chunk ${msg.data.chunk}: ${msg.data.prompt}`);
        break;
      case "prompt_switched":
        console.log(`Switched to: ${msg.data.new_prompt}`);
        break;
      case "error":
        console.error(`Error: ${msg.data.message}`);
        break;
    }
  }
});

Complete Example

import { Reactor, fetchInsecureToken } from "@reactor-team/js-sdk";

// Authenticate
const jwtToken = await fetchInsecureToken(apiKey);

const reactor = new Reactor({
  modelName: "helios",
});

// Set up video display
const videoElement = document.getElementById("video") as HTMLVideoElement;
reactor.on("trackReceived", (name, track, stream) => {
  if (name === "main_video") {
    videoElement.srcObject = stream;
    videoElement.play().catch(console.warn);
  }
});

// Listen for state updates
reactor.on("message", (msg) => {
  if (msg.type === "state") {
    document.getElementById("info")!.textContent =
      `Chunk: ${msg.data.current_chunk} | Frame: ${msg.data.current_frame}`;
  }
  if (msg.type === "event" && msg.data.event === "prompt_switched") {
    console.log(`Now showing: ${msg.data.new_prompt}`);
  }
});

// Connect
await reactor.connect(jwtToken);

// Set a seed for reproducibility
await reactor.sendCommand("set_seed", { seed: 42 });

// Schedule prompts for a cinematic sequence
await reactor.sendCommand("schedule_prompt", {
  prompt: "A peaceful forest at dawn, soft morning light filtering through the trees",
  chunk: 0
});

await reactor.sendCommand("schedule_prompt", {
  prompt: "Sunlight breaking through the canopy, golden rays illuminating the forest floor",
  chunk: 5
});

await reactor.sendCommand("schedule_prompt", {
  prompt: "A deer walking through the misty forest clearing",
  chunk: 10
});

// Start generation
await reactor.sendCommand("start", {});

Get Started

Concepts

Models

SDK Guides

API Reference

Key Features

Autoregressive Streaming

Image-to-Video

Real-Time Prompt Control

Quick Start

Model Name

Prompt Guide

How It Works

Commands

set_prompt

schedule_prompt

set_image

clear_image

set_seed

start

pause

resume

reset

Messages from Model

State Messages

Event Messages

Event Types

Complete Example

Get Started

Concepts

Models

SDK Guides

API Reference

​Key Features

Autoregressive Streaming

Image-to-Video

Real-Time Prompt Control

​Quick Start

​Model Name

​Prompt Guide

​How It Works

​Commands

​set_prompt

​schedule_prompt

​set_image

​clear_image

​set_seed

​start

​pause

​resume

​reset

​Messages from Model

​State Messages

​Event Messages

​Event Types

​Complete Example

Key Features

Quick Start

Model Name

Prompt Guide

How It Works

Commands

set_prompt

schedule_prompt

set_image

clear_image

set_seed

start

pause

resume

reset

Messages from Model

State Messages

Event Messages

Event Types

Complete Example