Collaborative translation: translate a Japanese game with a team, live

A whole game is a lot of text for one person. The obvious fix is to split it with friends — but historically that means everyone translates their own copy and someone stitches the pieces back together at the end, praying nobody touched the same file. Lines get translated twice, edits vanish in the merge, and you find out three weeks later when the dialogue contradicts itself.

Collaborative projects delete that whole problem. One person hosts a shared project; everyone else joins with a code and edits the sameproject at the same time, in the same editor — like a Google Sheet for game translation. You see each other's cursors and edits within a couple of seconds. No zipping, no merging, no "wait, which version is current?"

How it works at a glance

One member creates a collaborative project and gets a 20-character invite code. They share the code; teammates paste it and the whole project syncs down to their machine and opens in the normal editor. From then on, every edit anyone makes is pushed to the server and pulled by everyone else every couple of seconds. It is still a real local project on each person's disk — it just happens to stay in sync with everyone else's.

Starting a shared project (the host)

Creating a collaborative project is a Supporterperk ($3/mo). In the New Project dialog there's a Collaborativetoggle — flip it before you create, and instead of a purely local project, RuneTranslate uploads it and hands you an invite code (copied straight to your clipboard). Whoever creates it is the owner.

Why gate creation but not joining? Hosting a live shared project is the part that uses server resources, so it sits behind the same light, paid-to-host / free-to-use model as translation memory. Everyone you invite translates for free — the subscription covers the room, not the seats.

Joining (everybody else — free included)

Joining is free. Any signed-in user, free tier included, can join a collaborative project and edit it fully. On the Home screen, hit Join, paste the 20-character code, and the project downloads and opens. There is no read-only seat: if you're in, you can translate.

The code itself is 20 characters from a deliberately unambiguous alphabet — no look-alike 0/O or 1/I/L— with about 100 bits of entropy, so it isn't guessable. If a code ever leaks, the owner can regenerate it; the old one stops working immediately.

Who can do what

There are two roles, and they're simple:

• Owner(the creator) — can rename the project, regenerate the invite code, and remove members. The owner doesn't "leave" a project; they delete it.
• Editor(everyone who joins) — can edit any line, change a line's status, and leave whenever they like. Editors can't kick people or reshare.

There's no per-line locking or ownership — anyone can edit any cell. That's deliberate: it's what makes splitting the work by chapter, by file, or just by who's-online-right-now completely frictionless.

Seeing each other — live presence

This is the part that makes it feel like a shared doc. Each member gets a stable color (derived from their account, so it looks the same to everyone) plus their initials or avatar. While you work, you can see:

• Who's online— a presence dot that goes idle if someone hasn't pinged in for about 20 seconds.
• Which line each person is on— their colored marker sits on the cell they're editing, so you can watch the team move through the script.
• What they've selected— the "blue box." If a teammate marquee-selects a range of rows, you see that range highlighted in their color, so you know what they're about to work on (up to 500 rows at once).

Updates ride a poll: roughly every 2.5 secondswhile the window is focused (and a gentler ~8 seconds when it's in the background, to save bandwidth). So another translator's line shows up on your screen within about two to three seconds of them committing it. Near-live rather than instant — but more than fast enough to coordinate without stepping on each other.

What happens when two people edit the same line

Last write wins, per cell. If two people edit the same line at almost the same moment, the edit that reaches the server last is the one that sticks. In practice this rarely bites — you can see who's parked on which line — but it's the rule, so if you and a teammate both grab the same tricky line, talk it out instead of racing. Every line is independent, so simultaneous edits to different lines never conflict.

It's still your project — offline and export

A collaborative project is a normal .rtproj on your disk, not a thin remote window. That has two nice consequences. It degrades gracefully offline: if your connection drops, you keep translating, your edits queue locally, and they sync the moment you're back. And export works exactly like any other project— anyone with their own copy of the game files can build the translated game from the shared translations. The collaboration is about the text; you each still own your own game folder.

Shared projects expire after 15 idle days

A shared project isn't meant to live on the server forever. If one goes 15 days with no edits, it's automatically deleted — members and all. The project card shows an "Expires in N days"countdown that turns amber as the deadline nears, so it's never a surprise. Any edit resets the clock, so an active project never expires — this only reaps abandoned ones. If you want to keep a finished translation, take a local export before the clock runs out.

The fine print

• Up to 50 members per shared project.
• Translation memory and glossary stay personal. They're not pooled across the team — each translator's glossary and TM are their own, and your edits still seed your personal memory for future projects. To keep character names consistent across a team, agree on them up front or share a glossary CSV.
• You stay in control of quality. Each member can run the AI refiner and pick their own provider as usual; the shared project just holds the text.
• Signed-in only.Joining and editing require an account, and the collaboration endpoints use the same anti-tamper checks as the rest of the paid cloud features — so a shared project can't be poked at from outside the app.

How to run a team translation

1. Host: in New Project, flip Collaborative, create, and the invite code lands on your clipboard. (Supporter.)
2. Share the codewith your team however you like — a Discord DM works fine.
3. Teammates join:Home → Join → paste the code. The project opens for everyone.
4. Split the work— by chapter, by file, or just by who's online. Watch each other's colored cursors and selection boxes to stay in your own lane.
5. Translate normally. Every edit syncs in a couple of seconds; use the refiner and your own glossary exactly as you would solo.
6. When you're done, anyone exports against their own copy of the game. Grab a local export before the 15-day idle clock runs out.

Wrapping up

Solo machine translation gets a game to "readable." A team gets it good, and faster — and collaborative projects take the worst part of team fan-translation, keeping everyone's work merged and current, and just make it disappear. One person subscribes to host; everyone else joins free and translates the same living project, cursors and all.

Download RuneTranslate, start a collaborative project, and send your group a code.