Introducing TrackSpot Remote

I’ve been teasing this one for a little while now.

With TrackSpot 2.1, TrackSpot Remote is officially here.

Remote started from a pretty simple problem we run into constantly while broadcasting:

How do I let somebody else control part of my OBS production without giving them access to my computer, my entire OBS setup, or putting OBS directly onto the internet? How do I automate reptitive actions in a way that can be shared to others easily without plugins?

There are plenty of ways to remotely control a computer.

There are plenty of button decks.

There are plenty of ways of exposing OBS WebSocket.

None of those were really what I wanted.

I wanted to be able to build a control surface specifically for a production, send someone a link, and have them control exactly what I wanted them to control.

That's what became TrackSpot Remote.

OBS control, from anywhere

At its simplest, Remote lets you connect your local OBS instance to a browser-based control surface.

You build the layout on the computer running OBS.

Then, when you need another person involved, you start a Remote session and send them the join link.

They open it in their browser.

That's it!

They don't need OBS.

They don't need your scene collection.

They don't need remote desktop access.

And, importantly, you're not just handing somebody unrestricted access to OBS WebSocket.

The layout you've created becomes their control surface. If you give them ten buttons and two audio faders, that's what they get. Their actions are sent back to the host and executed against OBS on the host machine. That's the bit that really matters to me.

Remote isn't trying to move your production into the cloud. It's letting the cloud connect people to the production you're already running.

Build the controller you actually need

I didn't want Remote to be built around a fixed set of OBS buttons.

Every production is different.

A commentator controlling their own microphone needs something completely different from a producer handling replays. A person managing media needs something different again. Someone helping with transitions might need three buttons and absolutely nothing else.

So instead, Remote is built around layouts and macros.

You create the interface.

A macro might simply change a scene.

Or it might perform several actions in sequence.

You can control things like scenes, Preview, transitions, Studio Mode, sources, groups, browser sources, audio, streaming, recording, the virtual camera, replay buffer, filters, media and delays.

There are also Variables, which let a layout hold shared values that can be used during a production, and proper volume faders for controls that don't make sense as a simple button.

Macros can have their own labels, icons, colours and shapes, and can reflect the current state of OBS rather than just sitting there as dumb buttons.

That last part is something I've wanted from the beginning.

If something is muted, Remote should know it's muted.

If something is running, Remote should be able to reflect that.

A control surface should tell the operator what's happening, not just hope OBS did what they asked.

The easiest way to explain Remote is probably to actually see it

I've put together a set of example layouts here:

Explore the Remote examples

These aren't meant to be the only ways you can use Remote.

Quite the opposite.

They're there because once you stop thinking about Remote as "buttons for OBS" and start thinking about it as "an interface I can give to another person", there are a lot of interesting ways it can be used.

Stream Automation

The first example is probably the most traditional use of Remote.

Build out the common controls you need while running a stream and put them in one place.

Instead of digging through scenes, sources and OBS docks during a production, your regularly used actions can become clear, deliberate macros.

That could be as straightforward as moving through the different stages of a show, or you can start combining actions together so one button handles something that would otherwise take several steps.

This is also where Remote becomes useful even if you're sitting directly in front of OBS.

You don't have to have another operator.

Sometimes you just want a purpose-built interface rather than trying to operate the production through OBS itself.

Media Drops

This is one of the examples I particularly like because it shows Remote moving away from being a basic scene switcher.

Think sponsor assets.

Videos.

Stings.

Promotional graphics.

Holding content.

Anything that you need to introduce during a broadcast at the right moment.

Instead of telling another operator:

"Open this source, play that media file, wait until it finishes, then hide it again..."

You can build the workflow into the control itself.

Then the person responsible for those assets gets an interface designed specifically for that job.

They don't need to understand the rest of your OBS setup.

They just need to know which control to press and when.

That's really the philosophy behind the whole app.

Broadcast Assistance

This one gets much closer to the reason Remote exists in the first place.

Live productions very quickly become too much for one person.

You're watching what's happening, listening to commentary, checking levels, switching scenes, triggering replays, dealing with graphics and inevitably trying to fix something that has decided to break five minutes after going live.

But handing another person access to your entire production isn't always the answer either.

Remote lets you break pieces of that workload away.

Build an assistant layout.

Give somebody the controls relevant to their role.

They might handle graphics.

They might trigger replays.

They might manage particular sources.

They might have a handful of macros for moments throughout the show where you simply need another pair of hands.

You're not giving them OBS.

You're giving them their part of the production.

That's a fairly fundamental distinction.

Transition Management

The transition example takes the same idea and narrows it down even further.

Sometimes someone's job really can just be managing how you move between parts of a production.

So why give them 100 controls?

Give them the controls they actually need.

Remote supports OBS transitions and Studio Mode, including Preview controls, which means you can build a surface around preparing and executing changes without exposing the rest of the production.

And because macros can contain multiple actions, those controls don't necessarily have to represent individual OBS commands.

A single button can represent an actual production instruction.

Instead of:

"Change this, trigger that, wait, switch this..."

the button can simply be:

GO TO INTERVIEW

What that means underneath is up to the person who built the layout.

That, to me, is where Remote gets really powerful.

One host. Multiple operators.

Remote also isn't limited to one person connecting at a time.

A host can have multiple operators connected to the same session, with support for up to ten peers.

So you could potentially have one person handling media, another assisting the broadcast, someone else controlling audio, and the main broadcaster still working directly from the host.

They're all interacting with the same production, but they don't all need the same interface or access.

We've also put quite a bit of work into what happens when multiple people start doing things at the same time.

Macro execution is handled on the host, with controls around concurrent actions so two operators aren't blindly fighting over the same OBS resource.

Shared Variables and fader state are also controlled by the host and reflected between operators.

The host remains authoritative.

And yes, it works on a phone

This was important.

If the whole point is that somebody can operate remotely, requiring them to sit in front of another desktop computer felt pretty limiting.

The operator surface is designed to remain usable across desktop, tablet and mobile without completely rearranging the layout the host designed.

So if all somebody needs is a few controls, they can quite literally join from their phone.

That opens up some fun possibilities.

An interviewer could have controls with them away from the main production desk.

A floor operator at a live event could trigger something from a tablet.

Someone could be sitting on the other side of the world helping with your stream from their phone.

As long as the control surface makes sense for the device, Remote doesn't really care where that operator is.

What about actually connecting across the internet?

This was probably the biggest technical challenge of the project.

Remote uses encrypted modern protocol connections between the host and operators.

The TrackSpot side handles the short-lived rendezvous needed to get those people connected, but things like your OBS password and the actual definitions behind your controls aren't being stored server-side as part of that process.

Where a direct connection isn't possible because of the networks involved, Remote can fall back through the TrackSpot infrastructure.

And you can actually see whether the connection is operating directly or being relayed.

The goal throughout this has been pretty simple:

You shouldn't need to expose OBS itself to the internet just because somebody on the internet needs to press a button.

Your layouts stay yours

The layouts you build are stored in your browser and can be imported and exported as JSON.

That makes them portable as well.

Build something useful for one machine, export it and move it somewhere else.

Keep layouts for different productions.

Create a base layout and duplicate it.

Share one with somebody else.

We've also separated editing from what the remote operator actually sees.

You can work on your layout without immediately changing the controls underneath someone in the middle of a production, then explicitly publish the updated version to your operators when you're ready.

Again, it comes back to actually building this around live production rather than treating it as a generic remote-control page.

I want people to experiment with this

The four example layouts are really just starting points.

Have a look through them here.

Stream automation.

Media drops.

Broadcast assistance.

Transition management.

Take one and pull it apart.

Change it.

Build something completely different.

I think some of the most interesting uses of Remote are probably going to be things we haven't thought of yet.

For us internally, there were obvious problems we wanted to solve because they're problems we've experienced while producing broadcasts.

But Remote deliberately doesn't force you into our workflow.

You build the layout.

You decide what each control does.

You decide who gets it.

The Best Feature

The best feature of TrackSpot Remote is that it is completely free!

Yes, free.

We see this is a great baseline product to build on in the future and useful not only for producers, but also streamers, event operators and broadcasters.

All you need is a free TrackSpot account. You can sign up by clicking Login on the website.

This is Remote 1.0

And that's probably worth emphasising.

This is 1.0.

It's the first production release of something I've wanted TrackSpot to build for quite a while, and it's also one of the first big public examples of the software side of TrackSpot becoming a real product ecosystem.

There is a lot I still want to do with it.

But the foundation is finally here.

Build your controls.

Connect OBS.

Start a session.

Send someone the link.

Let them run their part of the show.

From anywhere.

Welcome to TrackSpot Remote.