Code contributions are paused while the core is changing fast, so a pull request would likely be outrun by the next change. Bug reports and ideas, though, are exactly what moves this list, and those are always welcome.

Coming next

The features we're working toward, roughly in order. Each one makes the watch party smoother or smooths over a rough edge.

  • `/rejoin` command

    Right now, if your connection hiccups, you have to quit and run the whole join command again. A /rejoin would quietly reconnect you while playback keeps going, so a blip stops being a big deal, especially on a long movie night.

  • Pick up where you left off

    Regular crews could rejoin without re-sharing a code and land right where the group stopped last time ("resume at 1:12:30?"). Less faff for recurring watch parties.

  • Handle mismatched playlists gracefully

    If people queued up slightly different sets of files, the one with fewer files can quietly fall out of sync at the end. junto should notice and keep everyone together as best it can instead of silently giving up.

  • Smoother scrubbing

    Dragging back and forth across the timeline currently makes junto chase every position and stutter in and out of buffering. It should wait for you to land somewhere, then fetch that, once. We're also fixing what happens when two people scrub at the same time, so the room settles on one spot instead of the two seeks fighting each other.

  • Watch without keeping the whole file

    A mode that only holds the part of the video around where you're watching, so you can watch a big film on a small drive without storing the entire thing.

  • Connect through stricter routers and networks

    The single biggest reason junto fails to connect for someone is a router or network that blocks a direct connection outright (hotel wifi, some workplace networks, stricter home routers). We're moving to a sturdier way of connecting, inspired by tools like Tailscale, that gets a direct line through far more networks and quietly falls back to an encrypted relay for the few that block it no matter what. As a bonus, the easier it is for friends to reach each other directly, the more of the room can pitch in when streaming from each other.

  • Start playback a few seconds sooner

    Right now junto waits for the entire connection handshake to finish before any video data can move. Trickling that handshake out a little at a time instead of all at once should shave real seconds off the wait between hitting join and actually watching.

Behind the scenes

You won't see these directly, but they keep junto dependable.

  • A relay client we own

    junto leans on a third-party library to talk to relays, and that library is no longer maintained. Building our own small replacement keeps junto reliable for the long haul and lets us fix things ourselves instead of waiting on code nobody's tending.

  • Signed installers on macOS

    The one-line installer now clears macOS's quarantine flag automatically as a stopgap, but Homebrew, the .pkg, and manual downloads still need a manual step, and Gatekeeper's "unidentified developer" warning doesn't fully go away until junto's binaries are properly signed and notarized. That's the real fix, still to come.

  • Verified auto-updates

    junto update will check a cryptographic signature on every release before installing it, on top of the checksum check it already does, so a bad or tampered update can never quietly slip through.

Probably not, at least for now

Genuinely interesting ideas, but each one would pull junto away from the single thing it's good at. We might revisit them once the core is truly solid, and only if they still earn their place.

  • Live stream rooms

    Sharing a live feed rather than a file. That's really a different product, and it would need a whole separate path through junto.

  • Torrents and other URL sources

    More ways to point junto at media. Useful, but it widens junto rather than deepening the watch party.

  • Adding files mid-session

    Tossing another video into a room that's already running. A nice convenience that adds real complexity for a small payoff.

  • Multiple rooms at once

    Hosting several watch parties from one machine. junto is about one party with your friends, not running a venue.

  • Shell hooks

    Custom commands that fire on join or play (Discord pings, smart-home tricks). Fun for power users, but niche.

  • Other players

    junto is built around mpv, and you watch inside mpv. Supporting more players is reach, not the core feel. (The terminal itself did get a proper interface, though: see Shipped.)

  • A full graphical app, no terminal

    A real windowed app with the video built right in, so a friend who's never touched a terminal could open junto and join in one click. Genuinely tempting, but it's close to a second product to build and keep maintained, so it waits until the terminal experience is completely solid.

  • A phone remote control

    A lightweight companion app that lets someone join a room and control playback from their phone, without watching the video there. Solves a real "my friend's stuck on their phone" moment, but a whole separate mobile app is a lot of new surface area for a corner case.

  • Windows support

    A real gap we'd like to close, but worth doing after junto is rock-solid on macOS and Linux.

  • Deeper relay and messaging protocol features

    Plumbing-level niceties you would never notice during a watch party.

Shipped

  • The shakiest connection gets served first When the host feeds several friends at once, it used to split its upload evenly, so someone barely keeping up got no more help than someone way ahead. Now everyone quietly tells the host how much they've buffered, a friend who's comfortably ahead eases off for a moment, and whoever's closest to freezing gets served first. Because the whole room pauses whenever anyone stalls, keeping the shakiest connection fed is what keeps the movie rolling for everybody. (Bigger swarms also share more evenly now: friends pulling spare parts from each other spread across different parts instead of all grabbing the same one.)

  • A real interface in the terminal junto used to be plain scrolling text with a single progress bar pinned at the bottom. Now, on a real terminal, it draws a proper screen: a banner, a room panel with your code and join link, and a live party panel showing everyone in the room, where each person is in the movie, how far their download has gotten, and whether they're ready, buffering, or lagging, with your own name highlighted. Chat and notices read as their own thing below it. It only kicks in when you're actually on a terminal, so piping junto's output into a script or a log file stays exactly as plain as before, and there's a switch to force plain output if you prefer it.

  • Stream from everyone, not just the host Joiners now pull the file from any friend who has the bytes: someone mid-download, someone who brought the file along, or someone whose download already finished. The host's upload speed is no longer the ceiling for the whole room. Every chunk is checked against the host's announced fingerprint (BLAKE3) the moment it arrives, before it's played or saved, so an extra source can never slip in bad data; a corrupt one is caught on its first bad chunk and dropped for good. This also closes the last host-drop gap: a room where nobody brought the full file can still finish the movie together, and a friend whose download completed can take over hosting so late joiners still get in. Older versions keep watching alongside newer ones exactly as before.

  • The one-line install works everywhere now curl junto.watch/install | sh was quietly broken for Linux and any Mac without Homebrew already installed. Fixed, along with a handful of smaller rough edges: a safer way of piping the script into your shell, clearer errors when GitHub is rate-limiting you, and a double-click macOS .pkg that reliably installs mpv too.

  • Homebrew now installs via a cask The command is now brew install --cask swayam-mishra/tap/junto; brew upgrade keeps working the same either way.

  • No more permanent freeze from one slow or stuck peer A friend whose download can't keep up used to pause the whole room indefinitely, with no way out but kicking them. Now the room automatically carries on after a short wait, and they rejoin in sync the moment they catch up.

  • A heads-up before a stream stutters, not after junto now works out a video's real bitrate and warns you upfront if your connection (or, for a host, your upload) looks too slow for it, instead of you finding out mid-movie.

  • Disk-space check at join Joining a streaming room now warns you right away if the playlist won't fit in your free space, instead of failing partway through a long download.

  • A big batch of sync and connection reliability fixes A full code review turned up and fixed a long list of edge cases: a playback-speed nudge that could get stuck a little too fast, a rare hiccup that could reset everyone to the start, streaming that could stall at a fixed point in every file, a seek that could get lost mid-download, a playlist jump that could freeze the session, a kicked troublemaker still being able to kick others, a friend reconnecting after a network blip getting hard-seeked repeatedly, the built-in relay's credentials going stale mid-session, a brief connection flap forcing a full reconnect, a seek downloading far more than it needed to, and two similarly-named files confusing subtitle matching. None of these hit everyone, but each was a real, occasional annoyance, now closed.

  • Closed a few security gaps A clock-skewed or malicious peer could freeze everyone's controls; an old message could be captured and replayed later to disrupt a room; telemetry could silently ignore your opt-out on a config typo; and junto update could silently skip its own checksum check if verification failed. All four are fixed.

  • Sturdier sync, tested end to end junto's syncing can now be exercised from start to finish without launching a real player, and a two-room test checks that play, pause, speed, seek, and skipping through a playlist all stay in lockstep. In plain terms: whole classes of sync bugs get caught before a release ever reaches you.

  • Graceful host migration When the host quits or drops mid-session, the room no longer dies. A friend who has the files is picked as the new host automatically (everyone works out the same winner on their own, with no extra coordination), re-announces the playlist so late joiners still connect, and streaming joiners redirect their download to the new host. Every byte stays verified across the handover. (The one remaining gap, when nobody present had the full file, is now closed by streaming from everyone, above.)

  • Stale host detection If the host closes mpv or loses internet, joiners no longer hang silently. junto says "host appears to have left, waiting..." after a missed heartbeat and escalates to a "gone for X minutes, use /quit" notice after a longer gap, shown both in the terminal and inside mpv. When a replacement host takes over, the warning clears itself.

  • Smart readiness gate A streaming joiner no longer reports "ready" the instant mpv loads the file and then stalls on the first frame. The gate now holds until a real cushion of video sits ahead of the start, so "press play" is followed by playback. Local-file joiners and the host are ready immediately, as before.

  • File-match check A joiner who brings their own copy is warned at join time if it doesn't match the room: a different file count, a name that doesn't line up, or a size mismatch ("likely a different cut"). Name and size are checked instantly, so joining stays fast. Catches a whole class of baffling silent desyncs.

  • Smooth drift correction Small drift now glides back into sync by briefly nudging playback speed up to 3% instead of a jarring jump; hard seeks are saved for larger gaps. The nudge is purely local, so each peer corrects its own drift without dragging the room's speed around. Makes routine sync invisible.

  • One-command install curl junto.watch/install | sh works out your platform, downloads the binary (checksum-verified), and installs mpv for you. On macOS it uses the Homebrew tap when you already have it, and there's a double-click macOS .pkg on the releases page too. Turns "install a developer tool" into "run one line."

  • Guided failure and preflight junto checks for mpv before connecting, so a missing player fails instantly with install steps instead of after a ten-second wait. Connection, relay, and NAT errors now point you at junto doctor, the old NAT jargon is rewritten in plain English, and doctor ends with a one-line verdict.

  • Built-in connection relay When a direct connection can't get through a strict router, junto retries through a built-in relay automatically, with no flags and no setup. The number-one reason "it doesn't work for my friend," handled. -turn still lets you bring your own.

  • Audio track sync The active audio track now mirrors across the room, just like subtitles. On multi-audio files (dubs, multi-language releases), one person switching to the English dub switches it for everyone instead of leaving them stuck on the original.

  • Anonymous usage ping A single anonymous ping on create or join tells us whether things actually work in the wild: the event, version, OS and architecture, outcome, relay latency, and time-to-first-frame for streamers. No personal data, no room secret, no file names. The first run shows exactly what's sent, and --no-telemetry (or telemetry = false) turns it off for good.

  • Debug logging Add -debug to write a structured log of relay health, connection negotiation, downloads, and sync decisions to ~/.cache/junto. Off by default, and the first thing to reach for when something misbehaves.

  • Buffer-free playback The room now pauses only when someone is genuinely out of data, not as a precaution. A large playback buffer and an instant start coexist, fixing the case where minutes of video are cached but playback is still frozen. The download follows the playhead and adjusts to your connection speed instead of always racing from the start of the file.

  • In-player notices Chat, join/leave events, buffering, pause/resume/seek, kicks, relay reconnects, and the "press Enter to start" prompt now appear as overlays inside the mpv window where you're actually looking, mirrored alongside the terminal. Handled off the sync loop so a slow mpv connection can't stall the room.

  • Tighter sync junto now measures the real clock difference between you and each friend on join and accounts for it when correcting drift. The threshold for a sync correction tightened from 1 second to half a second. Bad measurements are discarded so a noisy sample can't make things worse.

  • Relay health scoring Play, pause, and seek go through the fastest reachable relay automatically. Relays that fail repeatedly get a short cooldown then rejoin the rotation. junto doctor now shows each relay's round-trip time.

  • One-tap join link junto create puts https://junto.watch/join#<code> on the clipboard. The junto.watch /join page shows friends exactly how to join. The room secret never hits the web server.

  • Watch from a URL junto create <url> (YouTube or any site yt-dlp supports) downloads and hosts the video like a local file. 1080p by default, cached so you only download once. Needs yt-dlp and ffmpeg installed.

  • `junto update` and `junto uninstall` Update to the latest release with one command, or cleanly remove junto. Add -purge to also wipe settings and cache.

  • Much faster file transfers One connection now serves a whole file instead of rebuilding every 4 MiB. Fixes constant stalls on HD and 4K files, and seeking no longer causes a reconnect pause.

  • Reliable mp4 and mov startup junto now fetches the right part of the file first, so long films and 4K recordings start up reliably instead of sometimes stalling.

  • Config file ~/.config/junto/config.toml saves your nickname, relays, mpv path, and connection settings. Flags still override.

  • Automatic subtitle sharing Subtitle files next to a video are shared and loaded automatically. Everyone gets the same subtitles, no separate step needed.

  • Resumable downloads Quitting mid-session keeps your progress. Rejoining picks up where it left off.

  • `/ignore`, `/kick`, `/sync` Locally mute a peer, ask a peer to leave, or force a resync without quitting and rejoining.

  • Richer `/peers` See each person's playback position, drift, download progress, and whether they're buffering or ignored.

  • `junto doctor` Checks mpv, your internet connection, NAT traversal, relay reachability, disk space, and yt-dlp/ffmpeg before you invite anyone. Prints a fix for whatever fails.

  • Playlist support Host multiple files and everyone watches them in sequence together. Joiners download every file in the playlist. Everyone advances at the end, or the host can skip forward.

  • Playback speed sync Changing speed in mpv mirrors to everyone, and drift correction accounts for the current rate so sync stays accurate at non-1x speeds.

  • Nick colors Each person gets a consistent color in the terminal derived from their session ID. Makes it easy to tell who said what at a glance.

  • Helpful error messages Bad room code, host not running, mpv not found, NAT traversal failing: each gets a plain-English message that tells you what happened and what to try next. No stack traces.

  • Transfer progress bar A live bar showing download percent, speed, and time remaining, pinned to the bottom of the terminal so chat scrolls above it without mixing in.

  • Encrypted sync messages All coordination (play, pause, seek) is encrypted before it leaves your machine. The relays passing messages between friends can read none of it.

  • Synced controls Play, pause, seek, speed, subtitle track and delay, and playlist position all mirror to everyone within about a second. No single person is in charge.

  • Readiness gate The host sees who's loaded and ready, then starts the whole room at once with one keypress. Late joiners skip to wherever the room is.

  • Buffering together If someone seeks past what they've downloaded, the whole room pauses until everyone has caught up, then starts together.

  • Streaming playback Files play within seconds while they download in the background. You don't wait for the whole thing.

  • Resumable transfers A dropped connection picks up from the last byte instead of restarting.

  • Direct peer-to-peer transfer Files go straight from host to friends. No third party ever touches them, and each transfer is verified.

  • TURN relay support Route transfers through a relay when a direct connection fails, using -turn.

  • Late-joiner sync New peers land at the room's current position, speed, and subtitle state immediately on join.

  • Binary releases macOS (universal) and Linux (amd64/arm64). brew install --cask swayam-mishra/tap/junto pulls in mpv automatically.