Endless Access and Ink & Switch Launch Backstitch, a Real-Time Collaboration Plugin That Goes Beyond Git for Godot

The new open-source tool brings Google Docs–style collaboration to the Godot editor for artists, programmers, jam teams, indie studios, and classrooms alike.

Backstitch is now in public alpha. The plugin, developed by Ink & Switch under a brief commissioned by Endless Access and funded by the Endless Foundation, brings real-time version control and collaboration to the Godot game engine. You can try it today at backstitch.dev.

‍Read the press release here

Git wasn't built for games

Version control has long been a friction point in Godot development. Artists hit merge conflicts that break scenes. Programmers spend their time fixing teammates' Git issues instead of writing code. Less-technical contributors get locked out of projects entirely. Git was built for code, but games are far more than code.

We've lived this problem firsthand. During a game jam at GodotCon Berlin, a room full of experienced engineers spent most of their time cursing at merge conflicts instead of making a game. Will Thompson, Principal Software Engineer on the Threadbare games team, put it plainly:

"If we'd had this tool, that jam would have been so much better,  and we knew Git."

For learners, the wall is even higher. As Justin, Learning Design Lead at Endless Access, described it:

"without version control, a learner who doesn't like their changes has two options — manually undo everything, or start over. There isn't much in between."

What Backstitch actually does

Backstitch brings real-time, Google Docs–style collaboration directly into the Godot editor. Whenever you save, your changes are automatically shared with your team, with intelligent automatic merging so you're never stuck with a broken scene. Teams can view a full history with visual diffs, revert to older versions, and create and merge branches — all without leaving Godot or touching a terminal.

A few things that make it different in practice:

History that persists. Godot already has a built-in undo history, but it resets when you close the editor. Backstitch keeps a full snapshot history across sessions. Every save is recoverable.

Visual diffs that make sense. When you look back at a change, you don't just see a text diff — you see what moved in the scene, highlighted in the editor. If a coin moved, you see where it was and where it went. If a player's speed changed, you see the before and after value.

Reverting is non-destructive. Going back to an earlier version doesn't erase what came after it. The revert itself becomes a new entry in the history, so you can always change your mind again.

Branches without the complexity. You can create a branch, experiment, and merge it back — or abandon it — all from inside the editor. As Will described it during a recent demo: branch early, branch often. If an experiment doesn't pay off, you just don't touch the branch. You're done.

Shareable playable links. With one click, a learner or developer can share a playable version of their game directly from their Backstitch project — no hosting setup, no export process. This alone has changed how feedback works in our programs.

"Get out of the way and enable creative work"

Paul Sonnentag, researcher at Ink & Switch, described the core goal simply:

"Version control is something anyone should have access to, not just programmers. Students don't care about version control. They want to build a game and collaborate quickly. That's exactly the right demand: get out of the way and enable creative work."

That philosophy shaped how Backstitch was built. It isn't a simplified toy built for classrooms and nothing else. It works inside Godot,  a real, professional game engine that indie studios use to ship commercial games. Early feedback has come from indie developers who want it for their own projects, not just from learners.

At the same time, the classroom use case has driven some of its most important design decisions. Justin captured what that looks like in practice: a learner who's new to game development, already managing the complexity of Godot, can start building good version control habits — branching, experimenting, reverting without having to first climb the Git learning curve. The foundations transfer. The overwhelm doesn't.

Currently in alpha, with real-world testing underway

Backstitch is in alpha, and the current focus is gathering feedback from real-world use. Endless Access is testing the plugin with students in an upcoming game jam and across its learning programs, while Ink & Switch is engaging Godot developers and indie teams to try it in their own workflows. Early use within Endless Access — including prototyping work on Threadbare, the open-source game with a Best of GDC mention — has helped shape the tool.

Will described what that prototyping process looked like: starting solo on main, then pulling in colleagues Manuel in Argentina and Sarah on the games team for real-time level dressing sessions, then exporting cleanly back into the main Git repository when the work was done. "When we were working together in real time, it was real time. When we were working separately, the same tool just worked."

Backstitch supports both online sync and fully offline workflows. It is free and open-source, and was recently presented at GodotCon Amsterdam in the session Beyond Git: Real-Time Version Control for Godot.

See it in action

The best way to understand what Backstitch does is to watch it running. In a recent episode of the Loom Lounge — Endless Access's live behind-the-scenes show where we build Threadbare in public — Will and Justin ran a live demo of the tool with Paul from Ink & Switch, including a real-time collaboration session where two developers worked on the same project simultaneously from different locations.

‍

You can try Backstitch today at backstitch.dev. If you're building in Godot — as a student, an indie developer, or a team — we'd love to hear what you think. Join the conversation on our Discord or reach out directly.

‍