Velum Studio developer documentation
Build with Velum Studio
Velum Studio is a broadcast app for streamers. Everything it can do from a button, your code can do too: switch scenes, mix audio, go live, read chat as it arrives. Its look is a small set of tokens anyone can theme, and the extensions that will live inside it follow the same design rules as the app.
What you can build
The control API
JSON-RPC 2.0 over a local WebSocket. Every action is a typed method, every event a typed notification, and live state is pushed the moment it changes.
Read the API guideSDKs
Client libraries for C#, TypeScript and Python, generated from Studio's own catalog. They find Studio, reconnect on their own, and pair with Studio on another computer.
Pick a languageTheming
A theme is a small JSON file that sets a few tokens and inherits the rest. Theme Studio edits it live, checks contrast as you go, and exports a .velumtheme to share.
Extensions
Docks, sources and effects that live inside Studio. They take every color and size from the active theme, so they look like Studio made them.
See the modelStreaming
Where the stream goes and how: VELoQ to Velora.tv, and WHIP, RTMPS and SRT to other servers and platforms, with the health a control can show while it's live. VELoQ, our own transport made for Velora.tv, sends each source on its own track for a viewer mixer.
Read about streamingIntegrations
Stream Deck, Touch Portal and Bitfocus Companion, built on the same API. Every key, button and slider shows Studio's live state.
Browse integrationsVelum files
Scene collections, profiles, themes, presets and backups share one signed, verifiable container. Here is exactly how to read and write one.
Read the formatA first look
Studio writes a small discovery file when it starts, so a client on the same computer never asks for a port or a token. Here is the whole round trip in each SDK: connect, follow the scene on air, and put a scene on air.
using Velum.Studio;
await using var studio = await VelumStudioClient.ConnectAsync(new VelumClientOptions { ClientName = "My App" });
studio.SceneChanged += (_, e) => Console.WriteLine($"On air: {e.Name}");
await studio.SubscribeAsync(TopicType.Scenes);
var result = await studio.SceneSwitchAsync(new SceneSwitchParams { Scene = "Just Chatting" });
Console.WriteLine($"Switched to {result.Name}");import { connectLocal } from "velum-studio-client/node";
const studio = await connectLocal({ clientName: "My App" });
studio.on("scene.changed", (e) => console.log(`On air: ${e.name}`));
await studio.subscribe("scenes");
const result = await studio.sceneSwitch({ scene: "Just Chatting" });
console.log(`Switched to ${result.name}`);import asyncio
from velum_studio import EventType, TopicType, VelumStudioClient
async def main() -> None:
async with await VelumStudioClient.connect(client_name="My App") as studio:
studio.on(EventType.SCENE_CHANGED, lambda e: print(f"On air: {e.name}"))
await studio.subscribe(TopicType.SCENES)
result = await studio.scene_switch(scene="Just Chatting")
print(f"Switched to {result.name}")
asyncio.run(main())Prefer the wire? It's JSON-RPC 2.0, so any WebSocket client works. Connecting shows the handshake, and every method is in the reference.
How it fits together
- Integrations control Studio from outside: your scripts, control surfaces, chat bots, an app on a phone or tablet. They use the control API and the SDKs, and they're their own apps, with their own look.
- Extensions live inside Studio: dock panels, sources, effects, transitions. They follow the design guidelines and take their look from the theme tokens, so a theme restyles them along with everything else.
- Themes are data, never code. One file sets the tokens that Studio, and every extension, draws with.
Studio's catalog is the source of truth for all of it. The reference pages on this site are generated from it at build time, and the build fails if they fall out of step.

