ROADMAP

Where junto is headed

junto does one thing: a seamless, fast watch party. Everything here is judged against that one goal, and breadth is parked until the core is flawless. Open source, so it moves faster with help.

Contribute → See what already shipped

Now: make the core seamless

The short list standing between junto and "just works, instantly, for anyone." These take priority over everything else.

  • Fast, buffer-free playback

    The YouTube feel: starts instantly, never stalls. The fix is pausing the room only when someone is genuinely out of data, not as a precaution, so a large buffer and a fast start can coexist. Then smart read-ahead that follows the playhead and adjusts based on your connection speed, keeping enough buffer for instant back-seeks.

  • In-player notices

    People watch the video, not the terminal. Chat, join/leave events, "buffering...", and the "press Enter to start" prompt should all appear as an overlay inside the mpv window, not in a terminal nobody is looking at.

  • Built-in connection relay

    The number-one reason "it doesn't work for my friend." If a direct connection fails because of strict router settings, junto should fall back silently to a relay instead of failing with an error. Zero flags needed.

  • File-match check

    Warn a joiner whose local copy doesn't match the room's file, preventing a whole class of confusing silent desyncs. Already almost free to add.

  • Smooth drift correction

    Glide back into sync by briefly nudging playback speed instead of jumping to a new position. Only hard-seek for large gaps. Makes sync invisible instead of jarring.

Next: finish the rough edges

Still in service of the one thing, just lower on the list.

  • Streaming from multiple peers

    Take the host's upload out of the critical path so streaming stays fast with more than two people watching. Fetch pieces from anyone who has them, preferring whoever has the best connection.

  • Room persistence and resume position

    Regulars rejoin without re-sharing a code, and land where the group left off ("resume at 1:12:30?").

  • Tighter sync

    Measure the real delay between you and each friend when joining, then account for it when correcting drift. Less overcompensation, sharper sync.

  • Relay health scoring

    Route time-sensitive events like play, pause, and seek through the fastest available relay so controls feel snappier.

Under the hood

Not user-facing features, but they keep the core healthy.

  • Replace the archived relay library

    The third-party library junto uses for relay communication is no longer maintained. Replacing it with a small, purpose-built version removes a stale dependency and gives junto full control over its connection logic.

  • Testable sync engine

    Extract the player control interface so the sync logic can be unit tested without launching mpv. This makes it much easier to catch regressions before they reach users.

Parked: deliberately out of scope (for now)

Real ideas, but each widens junto instead of deepening the one thing. Revisit only once the core watch party is flawless, and only if it still earns its keep then.

  • Live stream URL rooms

    Relay a live feed peer-to-peer. A different product entirely (live, not watch-a-file-together) that would need a whole parallel code path.

  • Torrent and HTTP URL rooms

    Alternative media sources where junto only coordinates sync. Breadth, not depth.

  • Mid-session playlist (`/add`)

    Append media to a running room. Nice-to-have that makes the streaming pipeline mutable at runtime for a marginal gain.

  • Multi-room

    Host several parties from one process. Not the single-party experience.

  • Shell hooks

    User-defined on_join/on_play/etc. commands for Discord pings and smart-home setups. Power-user breadth.

  • More players (VLC, IINA) and a terminal UI

    The player is mpv and you watch in it, not in the terminal. Supporting other players is reach, not the core feel.

  • Windows support

    A real gap, but revisit after the core is solid on macOS and Linux.

  • Advanced relay auth and messaging protocols

    Protocol niceties that users don't notice during a watch party.

Shipped

  • 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.

  • 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 swayam-mishra/tap/junto pulls in mpv automatically.