Pick your goal

Make a VR trailer with a headset

What you get: footage that moves like a real head, rendered offline at up to 4K through your own camera and post processing.

1. Select your rig root (for Meta XR, OVRCameraRig) and add Add Component > SeedeXR > Kionjo Recorder.
2. Add three tracks: Head = the center eye camera (CenterEyeAnchor), LeftHand and RightHand = the hand anchors. Name the head track exactly Head: renders follow it.
3. Plan the shots in the Storyboard tab. Leave each as a Performance shot with Offline Render.
4. Connect the headset over Link or Air Link, put it on and enter Play mode. In the Shoot tab, press Stage, then Space to start and stop each take.
5. Take the headset off and stop Link. Stay in Play mode if the editor allows it, otherwise enter Play mode again without the headset.
6. Press Replay to check the motion, then Render selected take, or Render missing shots in the Cut tab.
7. Press Build draft in the Cut tab.

Make a flat game trailer with my own camera or Cinemachine

What you get: the same storyboard, render and cut flow, with a camera instead of a headset.

A camera you fly yourself

1. Add a Kionjo Recorder to your camera's rig and add the camera as a track named Head.
2. Shoot Performance shots: fly the camera in Play mode while recording, then render the take at the quality you want.

A camera that moves on its own (Cinemachine, Timeline, animation)

1. Set the shot's Type to Live Camera and its Target Seconds to the length you want.
2. Add a Kionjo Camera Source component and set its Camera. Without one, Kionjo uses the camera tagged MainCamera.
3. Use the source's On Render Started event to start your camera move, for example a Cinemachine shot or a Timeline.
4. In Play mode, press Render selected take. Kionjo renders the camera frame locked for the target length. No take is needed.

Plan the trailer before shooting

What you get: an animatic, a video of the storyboard. Every shot is its picture held for its planned length, with voice, subtitles and music placed exactly as the real cut will place them. Watch it with the team to agree on pacing before anything is shot.

1. Add the shots and cards. Give each shot a Target Seconds.
2. Give shots a picture: frame each place in the Scene view and use From Scene view in the Picture section, or drop an image on it.
3. Add the voice lines, subtitles and music cues.
4. In the Cut tab, press Build animatic. It lands in Kionjo/animatic/animatic01/.

Use my headset's own recording instead of re-rendering

What you get: a shot made from a video the device recorded, trimmed by the cut. No replay, no render.

1. Select the shot and set Output Mode to Device Capture.
2. Press Import capture and pick the video (MP4, MOV or MKV). Kionjo copies it into Kionjo/captures/<code>/ and uses it.
3. Set In Point and Out Point to the part you want. An Out Point of 0 means the end of the file.
4. Build the draft as usual.

Add voice over and subtitles

What you get: voice lines placed per shot, trimmed, faded, with subtitles burned into the video and written as subs.srt.

1. Select a shot or card and open Voice and subtitles. Add a line.
2. Set Audio Path (WAV, MP3, OGG, M4A or FLAC) and the Subtitle text. An empty subtitle means no subtitle for that line.
3. Set At: the seconds after the shot starts in the cut.
4. Pick a Trim Mode: Silence (the default) trims leading and trailing silence at -55 dB. Words trims to the first and last spoken word and needs Python with faster-whisper. Manual uses Trim In and Trim Out exactly as typed.
5. Style the subtitles once for the whole trailer in the storyboard settings: font file, font name, size, colour, outline and margin.

Add music that ducks under the voice

What you get: music cues joined with crossfades, pushed down while someone speaks, and a final mix normalised for loudness.

1. Open the storyboard settings and add cues to Music.
2. Per cue, set Audio Path, Trim In and Trim Out (0 = the end of the file), At (absolute time in the cut), fades (1.5 s in and 2 s out by default) and Volume (0.5 by default).
3. Consecutive cues crossfade over Music Crossfade Seconds (2 s by default). Set it to 0 to join them without a crossfade.
4. Tune Ducking if you need to: threshold 0.05, ratio 3, attack 40 ms and release 700 ms by default. Untick Enabled to switch it off.

Put sound effects on button presses

What you get: a sound in the cut at the exact moment something happened in the take, such as a button press.

1. Mark the moment in your game code: KionjoEvents.Mark("seal");. Or, without code, add a Kionjo Event Relay component, set its Event Name, and call its Mark method from a UnityEvent such as a Button's On Click.
2. Record the take. Every mark lands in take.json with its time.
3. On the shot, open Sound effects and add a cue. Set Audio Path and put the same name in Event Name.
4. Build the draft. The sound plays where the event happened, shifted by the shot's In Point.

using SeedeXR.Kionjo;

public void OnSealPressed()
{
    KionjoEvents.Mark("seal");          // optional payload: KionjoEvents.Mark("button", "Confirm")
}

Render in 4K

What you get: renders at 3840 x 2160, 60 fps, through your own camera with post processing.

1. Open the storyboard settings and set Render Preset to UHD2160p60.
2. Set Cut Preset to UHD2160p60 too, here or in the Cut tab.
3. Optional: under Render Quality, tick Enabled and choose a quality level, LOD bias, texture mip limit, forced anisotropic filtering or unlimited skin weights. They apply only while rendering.
4. In Play mode, render the shots again, then build the draft.

Finish the edit in Premiere or Resolve

What you get: every draft folder holds an FCP7 XML timeline, <Title>_draftNN.xml, next to the MP4 and the SRT.

1. Build a draft in the Cut tab.
2. Press Show folder.
3. Import the XML into Premiere Pro or DaVinci Resolve as a timeline.

Set the scene up per shot

What you get: each shot staged the same way every time: debug panels hidden, the right objects shown, the story at the right beat.

1. Select the shot and open Staging.
2. Drag scene objects from the Hierarchy onto Drop scene objects here to hide them for this shot, or onto the show zone. Kionjo stores them as hierarchy paths such as /Environment/Outside UI.
3. For anything else, write a Stage Command and implement IKionjoStageHandler on a MonoBehaviour in the scene. Kionjo passes the command to every handler, one after another, and waits for each coroutine.
4. In Play mode, press Stage in the Shoot tab. Check verifies the scene against the shot without changing it.

using System.Collections;
using SeedeXR.Kionjo;
using UnityEngine;

public class TrailerStage : MonoBehaviour, IKionjoStageHandler
{
    public IEnumerator Stage(string shotId, string stageCommand)
    {
        if (stageCommand == "verdict") { /* jump the story to the verdict */ }
        yield return null;
    }
}

Drive Kionjo from an AI agent or a script

What you get: every verb of the window as a Unity CLI command, plus a state file to watch. Kionjo works without any AI. An agent uses the same verbs a person uses.

1. Install com.unity.pipeline 0.9 or newer. Without it these commands are not compiled, and everything else still works.
2. Run commands from a terminal. Always pass --project-path: with two editors open, the CLI may otherwise answer from the other one.

unity command kionjo status --project-path "<your project>"

Every answer has ok and message.

The state file

The window writes Kionjo/state.json (under the storyboard's output folder) whenever something changes, at most twice a second. Watch it instead of polling the editor.

{
  "storyboard": "Assets/Trailer/Storyboard.asset",
  "title": "Baraza Trailer",
  "isPlaying": true,
  "isRecording": false,
  "currentShot": "ab72ffac99ba4865805fe10b224a88a7",
  "plannedSeconds": 64.0,
  "targetSeconds": 80.0,
  "shots": [
    {
      "code": "S01",
      "name": "Crane down on the dome",
      "takes": 2,
      "hasRender": true,
      "state": "rendered"
    }
  ],
  "job": {
    "title": "Render S03",
    "running": true,
    "progress": 0.44,
    "status": "frame 108 of 231"
  }
}

Recipe: render and cut overnight

1. After a shoot, stay in Play mode with the headset unplugged.
2. Run kionjo render with no shot: every shot missing a render is queued.
3. Watch state.json until job.running is false and nothing is queued.
4. Run kionjo cut.

Recipe: suggest a storyboard

1. Read the narration script and list the scene's main places.
2. Write a storyboard JSON: an opening card, shots grouped by beat, each with a location, a target length, its voice line and subtitle, and a closing card.
3. kionjo import --json draft.json --replace true, then kionjo cut --animatic true so the team can watch the pacing.