Replit's Multiplayer feature lets multiple users edit code simultaneously in the same project with live cursor tracking. Invite collaborators by clicking Invite in the top-right corner and sharing a link or entering email addresses. Each collaborator can start independent Agent tasks that appear on a shared Kanban board, and Agent handles merge conflicts automatically when changes are applied. Core plans support 5 collaborators; Pro plans support 15 plus 50 viewer seats.
Set Up Real-Time Collaborative Coding Sessions in Replit
Replit Multiplayer lets your team code together in real time, like Google Docs for programming. This tutorial covers how to invite collaborators, manage parallel tasks through the shared Kanban board, and use Agent independently without overwriting each other's work. Whether you are pair programming with a colleague or coordinating a team of builders, Multiplayer makes it possible to work on the same project simultaneously from any browser.
Prerequisites
- A Replit account on Core or Pro plan
- An existing Repl or the ability to create a new one
- At least one other person with a Replit account to collaborate with
- Basic familiarity with the Replit workspace layout
Step-by-step guide
Invite collaborators to your Repl
Invite collaborators to your Repl
Open your project in the Replit workspace. Click the Invite button in the top-right corner of the screen. You can invite people by entering their email address, their Replit username, or by sharing a direct invite link. Each invited user receives a notification and can join the workspace immediately. On Core plans you can have up to 5 collaborators, and on Pro plans up to 15 collaborators plus 50 additional viewer seats. Viewers can see code but cannot edit it.
Expected result: Invited users appear in the collaborators list and can open the Repl in their own browser.
Start coding together with live cursors
Start coding together with live cursors
When multiple users open the same Repl, each person's cursor appears in a different color with their username label. You see what everyone is typing in real time, similar to Google Docs. Edits are synced instantly across all connected browsers. You can click on a collaborator's avatar at the top to follow their cursor, jumping to whatever file and line they are viewing. This makes pair programming natural even when you are in different locations.
Expected result: You see colored cursors for each collaborator with their name labels, and edits appear in real time.
Use the Kanban board for parallel Agent tasks
Use the Kanban board for parallel Agent tasks
Each collaborator can start their own Agent thread to work on a separate feature or fix. These tasks appear on a shared Kanban board with four stages: Draft, Active, Ready, and Done. This board is visible to everyone on the team. When someone starts a new Agent task, Replit creates an isolated copy of the project for that task so changes do not interfere with other people's work. Tasks move across the board as Agent completes them.
Expected result: The Kanban board shows all active and completed Agent tasks from every collaborator.
Review and apply completed tasks
Review and apply completed tasks
When an Agent task reaches the Ready stage, any team member can review the changes before applying them to the main codebase. Click on the task card to see what was changed, including new files, modified code, and deleted files. If the changes look correct, click Apply to merge them into the project. Agent handles merge conflicts automatically if multiple tasks modify the same files. If a merge fails, Agent will attempt to resolve the conflict and ask for guidance if needed.
Expected result: Applied changes merge into the main codebase and the task moves to the Done column.
Use the Shell for collaborative terminal access
Use the Shell for collaborative terminal access
All collaborators share access to the same Shell instances. When someone opens a Shell and runs a command, other collaborators can see the output if they open the same Shell tab. You can open multiple Shell instances for parallel work. Be aware that running destructive commands like rm or git reset affects everyone's workspace. Coordinate terminal usage through the Kanban board or a chat tool to avoid stepping on each other's work.
1# Example: one collaborator installs a package2npm install socket.io34# All collaborators immediately have access to socket.io5# because they share the same filesystemExpected result: Shell commands and their output are visible to all collaborators sharing the same Repl.
Manage secrets safely in a collaborative workspace
Manage secrets safely in a collaborative workspace
Secrets stored through Tools then Secrets are visible to all collaborators who have edit access. Collaborators can see both secret names and values. If you need to share API keys with your team, this is convenient. However, be aware that anyone with collaborator access can read and modify secrets. When a collaborator is removed, rotate any sensitive secrets they had access to. Viewers cannot see secret values at all.
Expected result: All collaborators can access and use secrets in the shared workspace.
Complete working example
1// Real-time collaboration demo: a shared counter app2// Multiple collaborators can edit this code simultaneously3// and see each other's changes in real time.45import express from 'express';6import { createServer } from 'http';7import { Server } from 'socket.io';89const app = express();10const httpServer = createServer(app);11const io = new Server(httpServer);1213let counter = 0;14const activeUsers = new Set();1516app.get('/', (req, res) => {17 res.send(`18 <!DOCTYPE html>19 <html>20 <head><title>Collaborative Counter</title></head>21 <body>22 <h1>Shared Counter: <span id="count">0</span></h1>23 <p>Active users: <span id="users">0</span></p>24 <button onclick="increment()">+1</button>25 <button onclick="decrement()">-1</button>26 <script src="/socket.io/socket.io.js"></script>27 <script>28 const socket = io();29 socket.on('update', (data) => {30 document.getElementById('count').textContent = data.counter;31 document.getElementById('users').textContent = data.users;32 });33 function increment() { socket.emit('increment'); }34 function decrement() { socket.emit('decrement'); }35 </script>36 </body>37 </html>38 `);39});4041io.on('connection', (socket) => {42 activeUsers.add(socket.id);43 broadcastState();4445 socket.on('increment', () => { counter++; broadcastState(); });46 socket.on('decrement', () => { counter--; broadcastState(); });47 socket.on('disconnect', () => {48 activeUsers.delete(socket.id);49 broadcastState();50 });51});5253function broadcastState() {54 io.emit('update', { counter, users: activeUsers.size });55}5657httpServer.listen(3000, '0.0.0.0', () => {58 console.log('Collaborative counter running on port 3000');59});Common mistakes
Why it's a problem: Two collaborators editing the same file at the same time in the editor, causing jumbled code
How to avoid: Coordinate through the Kanban board or work on different files. For AI-assisted changes, use separate Agent tasks which run on isolated copies of the project.
Why it's a problem: Running destructive Shell commands like rm -rf without warning collaborators first
How to avoid: Communicate before running commands that modify the filesystem. Consider using Git branches or checkpoints so you can revert if something goes wrong.
Why it's a problem: Assuming viewer-level users can run code or access the Shell
How to avoid: Viewers can only see the code. If you need someone to test or run the app, they need full collaborator access. Use the preview URL to share the running app with non-collaborators.
Why it's a problem: Not realizing that Agent tasks on Core plans run sequentially, causing long waits for the team
How to avoid: Upgrade to Pro for parallel task execution (up to 10 simultaneous tasks). On Core, prioritize tasks and avoid queuing large Agent requests during active collaboration.
Best practices
- Use the Kanban board to assign and track tasks instead of having multiple people edit the same file simultaneously
- Review Agent-generated changes before applying them to catch accidental code deletions or bugs
- Rotate secrets and API keys when removing collaborators who had edit access to your workspace
- Open separate Shell instances for independent terminal tasks to avoid conflicting commands
- Use Pro plan parallel task execution to let multiple Agent tasks run simultaneously instead of waiting in a queue
- Follow your cursor to a collaborator by clicking their avatar if you need to see what they are working on
- Coordinate deployment actions so only one person publishes at a time to avoid confusion
Still stuck?
Copy one of these prompts to get a personalized, step-by-step explanation.
I am using Replit's Multiplayer feature for team development. Explain how the Kanban board works for parallel Agent tasks, how merge conflicts are resolved when multiple people make changes, and what the differences are between Core and Pro plans for collaboration.
Set up a real-time collaborative feature for my app. I want multiple users to see each other's changes live using WebSockets. Create a Socket.io-based setup with a shared state that syncs across all connected clients. Use Express for the server.
Frequently asked questions
Core plans support up to 5 collaborators. Pro plans support up to 15 collaborators plus 50 additional viewer seats. Enterprise plans offer custom limits.
Yes. Collaborators with edit access can see both secret names and values in the Secrets tool. Viewers cannot see values. Rotate secrets when you remove collaborators.
In the editor, Replit syncs changes in real time similar to Google Docs. Both people's edits appear as they type. For Agent tasks, Replit creates isolated copies of the project and handles merge conflicts automatically when changes are applied.
Multiplayer is available on all plans, but meaningful collaboration requires Core or Pro. The free Starter plan does not include collaborator seats for private projects.
Yes. Any collaborator with edit access can publish and deploy the app. Coordinate deployments so only one person publishes at a time to avoid confusion.
The Kanban board organizes tasks into Draft, Active, Ready, and Done stages. Any collaborator can create tasks and move them through stages. For more structured project management, teams working on production Replit apps can partner with RapidDev to establish development workflows.
Yes. Click the Invite button, find the collaborator in the list, and remove their access. They will immediately lose the ability to view or edit the project.
Replit's workspace loads in mobile browsers but the editing experience is limited. Multiplayer features like live cursors and Agent tasks work best on desktop browsers.
Talk to an Expert
Our team has built 600+ apps. Get personalized help with your project.
Book a free consultation