Collab Editor

You create a session and get a link. Anyone who opens that link joins the same shared document, and from then on every change one person makes appears in everyone else's editor almost immediately.

Under the hood the editor uses a peer-to-peer connection between browsers. When you share the link, a direct channel is established between participants and edits travel over that channel rather than through a central server that holds your code. Each person's cursor and selection are broadcast too, so you can see where your partner is working and follow along.

Key features:

• Real-time sync of text, cursors, and selections
• Shared link entry with no sign-up or invite flow
• Syntax highlighting for common languages
• Multiple cursors so you can see exactly where each person is
• Client-side only: the document lives in the participants' browsers, not on a server

Because it's just a web page, it works the same on any modern desktop browser without an extension.

Say you and a teammate are tracking down why a function returns the wrong total. You open a session and paste in the suspect code:

function sumPrices(items) {
  let total = 0;
  for (const item in items) {
    total += item.price;
  }
  return total;
}

You send the link; your teammate joins and immediately sees the same buffer. They drop their cursor on line 3, and you watch it move there in real time. They type a comment inline: // for...in gives keys, not values. You change in to of, and item.price resolves correctly. They highlight the loop to confirm, and you both watch the selection appear.

The whole exchange happened in one document instead of three round-trips through a chat window. Nobody had to re-paste anything, and there was no ambiguity about which line either of you meant.

• Pair programming across two machines without screen-sharing lag or handing over control. Both people can type, and you each keep your own keyboard and shortcuts.
• Technical interviews, where an interviewer and candidate work in a shared editor. There's no account to create under time pressure, and the candidate doesn't have to install anything.
• Code review walkthroughs, when a comment thread isn't enough and you want to edit alongside the author live.
• Teaching and mentoring, so a more senior developer can demonstrate a refactor while the learner watches the cursor and edits move.
• Quick clarification, when "do you mean this line or that one?" is faster to settle by both looking at the same buffer than by describing it in words.

The common thread is any situation where pointing at, editing, and discussing the same code in real time beats copying it back and forth.

A few things to know so a session goes smoothly:

• Keep the tab open. Because the document lives in the browser and syncs peer-to-peer, closing all participants' tabs ends the session and the shared buffer is gone. If you want to keep the code, copy it out before you leave.
• The link is the access. Anyone with the link can join, so treat it like a temporary shared secret and only send it to the people you're working with.
• Have at least one person stay connected while others come and go. The document persists as long as a participant is present to relay it.
• Network restrictions can interfere. Strict corporate firewalls or VPNs sometimes block the direct browser-to-browser connection; if sync stalls, a different network usually fixes it.
• Paste, don't retype. When you want to bring existing code into a session, paste the whole block at once rather than typing it line by line.

Most collaborative editors send every keystroke to a central server, which merges the edits and broadcasts them back out. That works, but it means your code passes through and is typically stored on someone else's infrastructure.

This editor takes a different path: edits are exchanged directly between the participants' browsers. A lightweight signalling step is only used to help the browsers find each other and open the connection; once that's done, the actual document content flows over the direct channel.

The practical consequences:

• Your code isn't uploaded to a server owned by the tool, and nothing is persisted after the session ends.
• Latency is low because edits take a short path between peers rather than a round-trip through a distant server.
• There's no account or history, which is exactly what you want for a throwaway interview or a quick pairing session.

The trade-off is that the session is ephemeral: there's no server holding a saved copy, so persistence is your responsibility. For the use cases this tool targets, that's usually a feature, not a limitation.