> ## Documentation Index
> Fetch the complete documentation index at: https://docs.reactor.inc/llms.txt
> Use this file to discover all available pages before exploring further.

# Helios overview

> What Helios is, its key features, and a quick start.

export const ModelRate = ({model}) => {
  const [data, setData] = useState(null);
  const [error, setError] = useState(false);
  const [loading, setLoading] = useState(true);
  useEffect(() => {
    const ctrl = new AbortController();
    fetch("https://api.reactor.inc/pricing", {
      signal: ctrl.signal
    }).then(r => {
      if (!r.ok) throw new Error(`HTTP ${r.status}`);
      return r.json();
    }).then(json => {
      setData(json);
      setLoading(false);
    }).catch(err => {
      if (err.name === "AbortError") return;
      setError(true);
      setLoading(false);
    });
    return () => ctrl.abort();
  }, []);
  if (loading) {
    return <span aria-label="loading pricing" className="inline-block h-4 w-28 rounded bg-zinc-950/10 dark:bg-white/10 animate-pulse align-middle" />;
  }
  const creditsPerDollar = data?.settings?.credits_per_dollar;
  const amountPerSec = data?.models?.find(m => m.name === model)?.rate?.amount_per_sec;
  const canRender = !error && creditsPerDollar && typeof amountPerSec === "number";
  if (!canRender) {
    return <span className="text-zinc-950/60 dark:text-white/60">see current rate below</span>;
  }
  const perHour = Math.round(amountPerSec / creditsPerDollar * 3600);
  const perSec = (amountPerSec / creditsPerDollar).toFixed(4);
  return <span>
      <strong>${perHour}/hr</strong> (${perSec}/sec)
    </span>;
};

**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](/model-api-reference/helios/schema), the
[prompt guide](/model-api-reference/helios/prompt-guide) for writing prompts that produce smooth
output, and an end-to-end [tutorial](/model-api-reference/helios/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`](/sdk-reference/reactor-class) 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

| Spec                 | Value                        |
| -------------------- | ---------------------------- |
| **Model name**       | `helios`                     |
| **Pricing**          | <ModelRate model="helios" /> |
| **Chunk size**       | 33 frames                    |
| **Super-resolution** | `off` · `2x` · `4x`          |

The **model name** is the string you pass when you open a session, e.g.
`new Reactor({ modelName: "helios" })`. See
[Pricing & Billing](/resources/billing) for how billing works.

## Key features

<CardGroup cols={3}>
  <Card title="Autoregressive streaming" icon="film">
    Continuous, infinite video stream with smooth temporal coherence across minutes of generation.
  </Card>

  <Card title="Image-to-video" icon="image">
    Provide a reference image to guide generation and swap it mid-stream.
  </Card>

  <Card title="Real-time prompt control" icon="wand-sparkles">
    Schedule prompt changes at specific points during generation for dynamic scene transitions.
  </Card>
</CardGroup>

## 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](https://github.com/reactor-team/js-sdk/tree/main/examples/helios)
directly, or follow the [tutorial](/model-api-reference/helios/tutorial) for a guided walkthrough.

<Tabs>
  <Tab title="npm">
    ```shell theme={"theme":{"light":"github-light","dark":"github-dark-high-contrast"}}
    npx create-reactor-app my-helios-app --model=helios
    ```
  </Tab>

  <Tab title="pnpm">
    ```shell theme={"theme":{"light":"github-light","dark":"github-dark-high-contrast"}}
    pnpm create reactor-app my-helios-app --model=helios
    ```
  </Tab>
</Tabs>

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](/quickstart) for the full walkthrough).

A minimal connect-and-generate flow looks like:

<CodeGroup>
  ```typescript TypeScript theme={"theme":{"light":"github-light","dark":"github-dark-high-contrast"}}
  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);
  ```

  ```python Python theme={"theme":{"light":"github-light","dark":"github-dark-high-contrast"}}
  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())
  ```
</CodeGroup>

That uses the base SDK. Helios also has a typed SDK, `@reactor-models/helios`, with named methods
(`setPrompt`, `start`, …) and React hooks; the [tutorial](/model-api-reference/helios/tutorial) uses it. See
[Typed Model SDKs](/sdk-reference/typed-model-sdk).

## 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`](/model-api-reference/helios/schema#set_prompt) or [`schedule_prompt`](/model-api-reference/helios/schema#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`.

<Note>
  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.
</Note>