Skip to main content
Everything runs through the reactor CLI. Install it, scaffold a project, and deploy it to Reactor’s GPUs. The CLI builds a container with the runtime already inside, so the only things you install on your own machine are the CLI and Docker.
Deployment access is granted per account. Contact us if the deploy step below is refused.

​
Install the CLI

Pinning a release in CI? See Install the CLI.

​
Scaffold a project

reactor init writes the model name as <org>/<name>. A bare name uses the org slug of your current credential, which the CLI reads live from the Reactor API. Before you sign in, pass the full name yourself: reactor init my-org/my-model. This creates a ready-to-run project:
The scaffolded model.py is a working model that needs no GPU. It streams the image in weights/ spinning over a field of static, and it accepts commands for the spin speed, a pause, and the static’s cadence, so you get frames, motion, weights, and a command round-trip before you write any code. Deploy it first, then replace it with your own model, written as a ReactorApp; the runtime’s examples/starter is the same model in that shape. reactor.yaml is the model spec. The scaffold pins the runtime release in build.runtime_version, so keep that generated value when you start. To upgrade, choose a release from the runtime changelog and update the field; a ReactorApp needs 3.5.0 or newer, and reactor init --runtime-version 3.5.0 pins it at scaffold time. Releases are immutable, so there is no latest to track. The reactor.yaml reference documents every key the file accepts.

​
Authenticate

This opens your browser so you can approve the login, then stores a key scoped to this machine. Over SSH, pass --no-browser and open the printed URL on any device.

​
Deploy it

That one command is the whole deployment. Run from the workspace with no arguments, it does five things in order:
  1. Reads the model and release from reactor.yaml.
  2. Registers the model if it does not exist yet.
  3. Publishes the release if it has no image, uploading the weights/ folder with it.
  4. Applies the model configuration.
  5. Activates the release on Reactor’s GPUs.
Docker has to be running, because the publish step builds your image locally before it pushes. Expect the first deploy to take a few minutes for that build and upload. runtime.weights_path in reactor.yaml is what names the folder that ships, and it points at ./weights in a fresh workspace. Your model reads the same folder back through get_weights_path(), both on Reactor and locally. Large weights can go up on their own with reactor weights upload, which does not rebuild the image. A public checkpoint can be an hf://org/repo reference instead of a folder. Weights covers both. To see what is registered and what is running:

​
Connect a client

Point the JS SDK at the model name from reactor.yaml, qualified with your account. A deployed model needs a token, so mint one on your server and read Authentication first. For the vanilla JavaScript example, add <video autoplay muted playsinline></video> to your page before running the script.
Confirm that the deployed model sends media and answers a command. A successful image build proves neither. The scaffold’s set_spin_speed is the quickest thing to call.

​
Ship a change

1

Edit your model

Change model.py, config.yaml, the weights, or anything else in the project.
2

Bump the release tag

Increment model.version in reactor.yaml, for example v0.0.1 to v0.0.2. A release that already has an image is reactivated as it is, so your edit needs a fresh tag.
3

Deploy again

The same command publishes the new release and activates it.
Configuration that lives outside the image, such as the deployment: block, applies again without a new tag. Quick iteration covers the full loop.

​
Develop against a local GPU

Deploying is the default path, and nothing above needs hardware of your own. With a local GPU, the same workspace also runs on your machine. reactor run starts the model in a container and puts the runtime’s logs in your terminal. It needs Docker, and it attaches no GPU unless you pass --gpus. Test locally walks through that loop end to end, with a model you can run and a Python client that checks its video and commands.

​
Next

Model Anatomy

Every member of a ReactorApp, read through one working model.

The Step Loop

The three hooks, refusing and failing, emitting, and the frame rate.

Load Your Weights

Resolve checkpoints the same way locally and in production.

reactor.yaml reference

Every key in the model spec, with its default.