Streaming
VELoQ
VELoQ is CLEARLYlogic's low-latency transport technology, built around the player and features of Velora.tv, and how Studio sends to Velora. What it adds is the sound: Studio sends each source on its own track beside the stream mix, so viewers get their own mixer and the VOD can leave your music out.
For streamers, the user guide Streaming to Velora with VELoQ covers the same ground without the wire details: going live on Velora, and what the Mixer's choices do there.
What VELoQ is
VELoQ is our own transport technology, made for what Velora.tv's player does: a viewer mixer built from the streamer's own sources, VODs that leave chosen sound out, and pictures that start fast. It's built on Media over QUIC Transport (draft 17, ALPN moqt-17), carried on WebTransport over QUIC with TLS verified, to a Velora ingest on port 4443. Studio links the VELoQ publish client, the same one Velora's OBS plugin ships, which runs on Google's QUICHE (QUIC, with BoringSSL).
The model is subscribe-driven. Studio connects and declares its tracks; the ingest then subscribes to catalog.json, which the library builds from those tracks, and to each track the catalog names. Every keyframe starts a new group, so a viewer can join at any keyframe, and Studio sends one every second.
Every stream Studio sends to Velora goes over VELoQ, and VELoQ is for Velora only. Any other server, including a WHIP server you add yourself, gets WHIP or the platform's own protocol.
Pictures
How many qualities go out is the streamer's choice: Qualities in What viewers can mix, or layers on veloq.send_with, 1 to 4, two by default. The first is the canvas itself at its full size (1440p60 goes out as 1440p60); each further one is the next of 1080, 720 and 480 lines below the canvas, so a 1440p60 canvas can send four (1440p60, 1080p, 720p, 480p) and a 1080p one at most three.
Each rung is an H.264 track named video0, video1 and so on (best first), format avc1, with its avcC as the track's init and its label (such as 1440p60) as its display name. A rung is registered on its first keyframe of each connection.
The encode is H.264 Main at a constant bitrate with no B-frames, in VELoQ's low-latency profile: x264's zerolatency tune, NVENC's low-latency tune, and keyframes only on the one-second grid.
| Rung height | Frame rate | Bitrate |
|---|---|---|
| 1440 lines or more (or 2560 wide) | any | 12,000 kb/s |
| 1080 | 50 or more | 8,000 kb/s |
| 1080 | under 50 | 4,500 kb/s |
| 720 | 50 or more | 4,500 kb/s |
| 720 | under 50 | 2,500 kb/s |
| 480 | 50 or more | 1,500 kb/s |
| 480 | under 50 | 1,000 kb/s |
The label carries the frame rate from 50 up, as whole frames per second: a 2560×1440 canvas at 60 goes out as 1440p60 at 12,000 kb/s with a 1080p rung at 8,000; 1920×1080 at 30 as 1080p and 720p; 59.94 is labelled 59.
That is Automatic. From beta.69 the streamer can choose Custom instead, in the Mixer's What viewers can mix › Qualities › Bitrate: the top rung goes out at the chosen rate, from 1,000 to 12,000 kb/s, and each rung below keeps its automatic share of it, rounded to 50 kb/s and never under 300 kb/s. A 1080p60 canvas at a custom 12,000 kb/s sends its 720p60 rung at 6,750.
Multitrack audio
This is what VELoQ adds: Studio sends the mix and each source's own sound beside it, taken after its fader, so muting or turning a source down in Studio's mixer applies on the stream at once.
Every audio track is Opus, 48 kHz stereo in 20 ms frames, with the OpusHead as its init. They're registered as the connection comes up, in this order. This is the full list Studio sends today:
| Track | Display name | What it carries |
|---|---|---|
program-mix |
Stream Mix | The stream mix (Studio's track 1), role program, 128 kb/s |
src-<n>-uuid:<id> |
The source's name | One source with its own viewer slider, with its group, source_id (uuid:<id>) and visibility |
send-<group id> |
The send's name | All the members of one send, on one slider |
bucket-hidden-vod-keep |
Stingers | Sources heard without a slider, kept in the VOD |
bucket-hidden-vod-drop |
Stingers (VOD-excluded) | Sources heard without a slider, left out of the VOD |
src-overflow-other |
Other | Sources past the eighth slider |
src-overflow-other-novod |
Other (not in VOD) | The same, left out of the VOD |
stem-<n>-uuid:<id> |
The source's name | Editor+ only: a source mixed with others, recorded on its own for editing. Role stem, never a viewer track, never in the VOD. |
Every track but the mix is 96 kb/s. Each track's metadata carries a visibility (public, publicDropVod, hiddenKeepVod, hiddenDropVod, excludedFromStream) and whether it's excluded from the VOD; its default volume and mute are sent only when the streamer has set where viewers' slider starts (the source's viewer_volume and viewer_muted), and left unset otherwise, because Studio's mixer is the baseline and each viewer's slider is their own.
Stinger sounds play on the stream mix, which VELoQ viewers don't hear, so when the collection has a stinger Studio plans its sound as one more source, the Transitions channel. By default it's heard without a slider and kept in the VOD (in Stingers); the streamer can give it any of the five choices.
Who gets a slider
Studio walks the collection's audible sources in the streamer's own order (then mics and app audio, then capture and games, then overlays, then media files) with eight viewer sliders to give. A source set to stay home gets nothing and is left out of the mix too; a send takes one slider for all its members; hidden sources are heard without one; past eight, sources share Other. A source that's silent, or only in "no audio" scenes, gets no track. The plan covers every scene, so switching scenes never reshuffles anyone's slider.
What viewers get
Velora's player builds a viewer mixer from the source tracks and leaves the program track out, so each viewer can turn your music down and your voice up. Viewers who watch over WebRTC or LL-HLS hear the stream mix. The VOD Velora makes leaves out every track marked to stay out of it.
What's fixed at Go live
Which tracks exist is set when the stream starts. A source added while live is heard in the stream mix and gets its own track next Go live; a removed source's track goes quiet. Volume and mute follow the mixer live.
A track's details change live on the same track: a source or send renamed, moved to another folder, kept in or out of the VOD, or given a new place where viewers' slider starts reaches Velora at once, and a reconnect registers the track with its new details. A change that adds or removes a track (a source moved between having its own slider, a send, Stingers or Not sent) waits for the next Go live, and Studio says so.
How a VELoQ Go live works
- Admission. Studio asks Velora, with the person's Velora session, where to publish. Velora answers with the ingest its router picked for this computer and the broadcast's path, which carries the stream key. Velora shows the channel live from here, so if anything after this fails, Studio tells Velora the stream ended.
- Connect. Studio dials
https://<ingest>:4443/velora/<path>. The library's handshake times out after 8 seconds, and Studio waits up to 12 for the session. The address is never logged or shown: status, logs and the API name the ingest by its host only. - Producer and tracks. Studio stamps the broadcast as
veloq-native(the player's VELoQ Native badge) with its own name and version,VelumStudio/<version>, registers the audio tracks, and asks the encoder for a keyframe at once so the new session starts on one. - Media. One timestamp origin covers the whole broadcast, shared by every track and kept across reconnects, so viewers still attached pick the new session's media up where it left off. Each track has its own queue and thread, so the encoder never waits on the network. When a video frame has to be dropped, everything after it is dropped until the next keyframe, so no viewer decodes from a picture that never arrived; audio drops the oldest packet.
- Live. The state turns
liveonce the main picture's first keyframe is out. Studio also sends Velora the channel's preview picture (480×270), the first a few seconds in, then every 15 seconds and 2 seconds after a scene change. - Stop. Studio sends what's queued (for at most half a second), closes the session, and tells Velora the stream ended, so the channel goes offline at once.
Reconnecting
A lost connection is retried while the person wants to be live; Studio never gives up on its own. The first retry is immediate and goes back to the same ingest, so the recording and VOD stay in one piece. From the second attempt on, Studio asks Velora again first; for a stream that's still live, Velora sends it back to the same ingest while that ingest is healthy. Attempts wait 2, 4, 8, 16, then 30 seconds; a connection that held for 15 seconds starts the count over. If the ingest refuses the stream key, Studio asks Velora once for a fresh admission (the key may have changed), and if that's refused too, the stream stops with state refused.
Support per operating system
Studio carries VELoQ wherever its build links the publish library:
| System | Publish library | Links with |
|---|---|---|
| Linux x86-64 | libveloq_publish.a, libvelora_libquiche.a |
Static ICU, the C++ runtime, dl, m, rt, pthread |
| macOS on Apple silicon | libveloq_publish.a, libvelora_libquiche.a |
libc++, CoreFoundation, Security, libresolv |
| Windows x64 | veloq_publish.lib, velora_libquiche.lib |
ws2_32, iphlpapi, bcrypt, crypt32, advapi32, userenv, dbghelp, ntdll; Studio built with the static C runtime and MSVC 14.44 or later, as the archives were |
There's no VELoQ library for Intel Macs, and Studio's Mac release is built for Apple silicon, so streaming to Velora needs Windows, Linux or an Apple silicon Mac. Release builds always carry the library; a build made without it can't go live on Velora, and Go live says so.
In the control API
Everything in What viewers can mix is in the API, in the VELoQ actions (catalog version 7):
| Action | What it does | Scope |
|---|---|---|
veloq.visibility |
Where a source's sound goes for viewers: public, public_drop_vod, hidden_keep_vod, hidden_drop_vod or not_sent; toggle_vod flips it in or out of the VOD |
manage |
veloq.viewer_start |
Where viewers' slider for a source starts (volume_percent), and whether it starts muted |
manage |
veloq.stem |
Records a source mixed with others as its own Editor+ stem | manage |
veloq.group |
Puts a source in an audio folder or send, or takes it out | manage |
veloq.slider_order |
A source's place in who gets the eight sliders first (0 is automatic) | manage |
veloq.transitions |
Where stinger sounds go | manage |
veloq.smart_defaults |
Gives one source, or every one, its smart first choice; with folders, sorts them into Voice, Game, Music and Alerts |
manage |
veloq.create_group, veloq.update_group, veloq.delete_group |
Makes, changes (name, folder or send, a send in the VOD or not) and deletes audio folders and sends |
manage |
veloq.send_with |
How many qualities Studio sends to Velora (layers); applies next Go live. Its protocol parameter is accepted but Velora always stays on VELoQ |
broadcast |
veloq.sliders |
Shows how many of the eight viewer sliders are taken | control |
A folder or send is named by the new audio_group parameter type, with its choices in the audio_groups topic. Changes that move a source to another track apply on the next Go live; a VOD flip on a source's own slider applies at once.
- The
audiotopic carries each source'svisibility,group,stem,viewer_volume,viewer_mutedandslider_order. - The
audio_groupstopic lists the folders and sends:name,kind,send_visibility,members. - The
veloqtopic is what a VELoQ Go live would send now: the audiotracksin order, the viewermixeras Velora's player draws it,sliders_usedofslider_limit, the sourcesnot_sent,has_stingerandtransitions. Destination.protocolon theveloradestination: alwaysveloq, withlayersbeside it. See Qualities for Velora.StreamProtocol:whip,veloq,rtmps,rtmp,srt.DestinationHealthwhile live over VELoQ:
| Field | Over VELoQ |
|---|---|
protocol |
veloq |
send_kbps |
Bits the publish library accepted over the last second, in kbit/s. kbps is the same number, since VELoQ has no bandwidth estimate. |
fps |
Main-picture frames sent per second, over the last second |
frames_published |
Frames the publish library put on the network in this connection (it starts over after a reconnect) |
frames_dropped |
Frames the publish library dropped in this connection |
dropped |
Frames Studio dropped before the library: while reconnecting, with a full queue, or waiting for a keyframe |
loss, rtt_ms |
null |
Destinations and protocols has the same fields side by side with those of a WHIP server you add.

