Nobody is here to do version control: How real-time collaboration in Godot is changing the game design classroom
Lilith Duncan still gets a little emotional about the class where she saw students working with Backstitch.
She'd been building Backstitch for months, the kind of work where you're so deep in fixing bugs and edge cases that you forget there are humans on the other end of it. Then she watched a room of learners share their game URLs with their instructor, all at once. Justin and his mentor Phoenix started clicking through them live, project after project, no builds, no setup, no waiting. And then the learners started playing each other's games.
“It was actually an emotional moment for me, seeing our hard work finally paying off. They could go through the rolodex of learner projects in class immediately. Learners were playing each other's games. It became a really collaborative environment that would never have been possible before.” Lilith Duncan, Lead Developer, Backstitch
Here's the funny part. The tool that made that moment possible is one we'd call a success if nobody in that room ever thought about it again. We didn't build Backstitch to be noticed. We built it to disappear.
A little context first. Endless Access is a nonprofit that helps young people get into game design as a path toward digital skills and creative careers. For years, the hardest part of that work wasn't teaching game design. It was teaching version control. So we partnered with Ink & Switch to build something better.
If you haven't come across them, Ink & Switch is an independent industrial research lab, the kind that doesn't sit inside a university or a big tech company, that has spent roughly a decade on what they call tools for thought: software that helps people think, create, and collaborate better. They're best known for popularizing local-first software, the idea that your data should live with you and keep working whether or not some company's servers do. Their open-source collaboration engine, Automerge, quietly powers a lot of this kind of work, and a sibling project called Patchwork is where the version-control thinking behind Backstitch first took shape.
Which brings us back to Backstitch, the outcome that this partnership produced: a Godot add-on that brings real-time, automatic collaboration right into the engine. Think: shared document, but for your entire game project. If you support learners and just want to dive in, it lives at backstitch.dev, and the full panel conversation this article draws from is super insightful, and totally worth watching.
Watch: The Backstitch panel conversation
Git isn't the enemy. It's the status quo.
With every pilot of our game development curriculum we ran into the same problem. Not that Godot was too hard, or GDScript too confusing, or that learners weren't ready— It was Git.
“The biggest pain point, all across the board, was Git. It was really hard for learners to understand how to use a version control system. And it was even harder to solve merge conflicts.” Andrea V. Pavon, Learning Program Specialist, Endless Access
Let's be fair to Git for a second. It's a remarkable piece of engineering, and for experienced teams it does its job. The trouble isn't that Git is bad. The trouble is that Git became the default, the thing everyone standardized on, and once a tool becomes the status quo, people mostly stop asking whether it's the right fit. They just adapt themselves to it and absorb the friction as the cost of doing business.
And as work gets more global, more distributed, and more importantly, multidisciplinary, the cracks in that status quo are starting to show. People still need to collaborate, more than ever, and every ounce of energy Git pulls toward branches, merges, and conflicts is energy not going into the actual creative work. For a professional that's a tax they've learned to pay. For a learner, it can be the thing that ends the journey before it starts.
Andrea watched it happen for years: her learners were there to make games, and the moment collaboration entered the room, Git stood between them. At Endless Access, we tweaked the curriculum so many times. We built workarounds. We iterated to the point of exhaustion,but the challenge never left. It was sitting upstream, baked into a default the whole industry had quietly agreed to live with. In many cases, completely blocking what could have been a life opportunity.
What is Backstitch? Real-time collaboration for Godot
When people make a game together in Godot, they need a way to share their changes. The usual answer is Git, which was built for sharing code. But games are so much more than code. There’s art, text, music, and effects. In other words, they're binary assets and structured scene data, and when Git hits a merge conflict in those files, scenes break.
Now you're leaving the editor to untangle it by hand, or, let's be honest about what usually happens, starting from scratch or giving up.
Backstitch does it differently. Lilith puts it about as plainly as it can be put:
“It's kind of like a Google Doc. Except it turns your Godot project into something you can all collaborate on, where everyone can edit at the same time. It's great for game dev teams, and especially great for classrooms.” Lilith Duncan
Real-time sync and automatic merging, right inside the engine, so nobody's stepping on anybody's work. Paired with it is the Webviewer: open a URL, play a Godot project in your browser, no build, no install. That last one sounds like a small convenience. It is not. It quietly rewired how a whole classroom works, and we'll get to that.
Why Git is hard for students learning game development
Today's learners grew up inside tools where your changes just appear and nothing is ever really lost. Git asks them to throw that mental model out and adopt a brand-new one, branches, commits, pull requests, local versus remote, before they've made anything fun yet.
Justin Bourque, who leads our learning design, is blunt about why that's such a tax:
“It's not just a technical or user-interface challenge. It's conceptually much more complicated than the Google Docs model people are used to.” Justin Bourque, Learning Design Lead, Endless Access
That load lands on top of everything a brand-new game maker is already juggling. You're learning design, logic, art, iteration, and then, oh, by the way, here's a version control system too. For a pro, that's an annoyance. For a learner still finding their feet, it can be the exact moment they decide this isn't for them.
Peter van Hardenberg, who directs the lab at Ink & Switch, frames it as a question of where a person's energy goes:
“People put in as much energy and passion as they have for a project. If they spend it messing with the tools, figuring out how to get the thing done, they don't have it left for the actual work. That's just friction lost along the way.” Peter van Hardenberg, Lab Director, Ink & Switch
His team even has a motto for it: nobody is here to do version control. People are here to make games. The job of a good tool is to get out of the way.
Why classroom tools should be invisible
Peter likes a saying from professional cycling: it doesn't get easier, you just get faster. The work is always going to be hard. A good tool doesn't pretend otherwise; it just makes sure the hard part is the part that's worth it.
Justin is teaching a course right now where learners use Backstitch every day. We asked how it was going. His answer was the highest praise the tool could get:
“Unless I prompt them, they're not talking about it. In the best possible sense. They're not talking about it because it's not a thing that needs to be talked about. It's just working for them.” Justin Bourque
That's the whole goal. Not a tool people rave about, a tool people forget they're using. And pulling that off across wildly different users is the genuinely hard part. Lilith describes the tightrope:
“We're making Backstitch for everyone. Programmers who live in Git and want fine-grained control, and learners who've never touched version control in their lives. Something that looks like a missing feature to a developer could be a huge stumbling block for an artist. So we're constantly re-evaluating.” Lilith Duncan
The fix isn't a dumbed-down version control for beginners. It's what Peter calls a small set of useful primitives anyone can recombine to fit the moment. Building blocks, not a single Right Way to do things.
The industry's actual solution is a hat
Here's the detail that genuinely delighted us. Ask how real studios keep collaborators from clobbering each other's work, and the honest, state-of-the-art answer is often... not software at all. It's an invisible hat.
Will Thompson, our principal game engineer, went around asking people in the industry how they actually handle this:
“The answer from everyone was: you have a special hat, and only the person wearing the special hat is allowed to touch the main scene. It might not be a physical hat. It could be some other token. But basically, that's the state of the art.” Will Thompson, Principal Game Engineer, Endless Access
To be clear, the hat is a social patch for a technical hole. Only one person can safely edit the shared scene at a time, so teams literally pass permission around by hand. It works, sort of, but it means coordination happens in spite of the tools instead of because of them. Will's take is that we can do a lot better than headwear:
“You can do better than the special hat. You can have the software do the hard work for you, which is supposed to be the point of good tools.” Will Thompson
And Paul Sonnentag, the Ink & Switch researcher who built the very first Backstitch prototype, sees the opportunity running both directions. Learners don't carry a professional's baggage, so they use these tools in ways pros never would:
“Learners don't have experience with version control, so they approach these tools completely differently from professionals. There's a huge opportunity to learn from that and bring it back to professionals, to make their tools easier too.” Paul Sonnentag, Researcher, Ink & Switch
It turns out branches are kind of calming
One of Justin's favorite effects has nothing to do with collaboration and everything to do with how learners think. Breaking a big, messy problem into smaller pieces is a skill most of us don't pick up until we're adults. Version control already does this under the hood; Backstitch just makes it something a learner can actually see.
Game making is messy and rarely goes in a straight line. Being able to branch, experiment, and keep a history of your work is valuable even for a learner working solo, long before anyone else joins in. It gives them the reset button and the undo-until-I'm-actually-happy that they expect from every other creative tool they touch, and that Godot, on its own, simply doesn't offer.
Instant feedback in the game design classroom
Remember that Webviewer we said we'd come back to? Here's where it earns its keep. When the gap between a learner's question and an actual answer collapses from days to minutes, people get brave. Justin tells a story about a learner who wondered whether their game would work on a phone:
“I had the confidence to just try it. Sent it with the Webviewer, made a QR code, held up my phone, scanned it, played it. Works on mobile. I genuinely didn't know where I was going with that. It was prompted by a learner being curious, and we all just got to find out together.” Justin Bourque
Picture the alternative. The learner asks, and you say, "Let me get back to you in a few days." By the time you do, the spark's gone out. The speed isn't really the point. The point is whether curiosity gets answered while it's still warm and how that enables more curiosity that leads to great discoveries and learning.
No two classrooms are the same
Backstitch is built around that fact instead of fighting it. A two-person indie team and a room of twenty students collaborate completely differently, and honestly, no two classrooms run the same way either. Branches are a good example of this:
A pro team usually works in feature branches: peel one off, build a feature, merge it back, delete it. Plenty of instructors do the opposite, giving each learner their own branch they live in over time, pulling the main project into it, and maybe merging their own work outward at the end of the week, if at all. Same tooling on the surface, genuinely different behavior underneath. Supporting both as first-class workflows, without turning the whole thing into a cockpit, is exactly the kind of problem the team is chewing on.
Your work belongs to you
One quiet feature matters more than it lets on: Backstitch works fully offline. Use the alpha test server, run your own for full privacy, or use no server at all and still get version control, branching, and history right on your machine. For programs in lower-connectivity places, that's not a bonus, it's the difference between usable and not. It also lines up with something we've believed since the early days of Endless OS: your creative work should belong to you, not to a platform that can pull the rug whenever it likes.
For an educator or program lead, that means a learner's work isn't hostage to some platform's business model. A program in a school in Guatemala has exactly the same ownership over its work as a studio in London.
Where this came from, and where it's headed
The connection to Endless Access started with a conversation between Peter and our CEO, Rob McQueen:
“Rob said, 'We have disinterested teenagers who really don't care about version control. Could you help them too?' And I thought, what an incredible opportunity. If ideas we tested with motivated professionals also work in a classroom, that's amazing for us as researchers, and we get to bring those findings back to everybody.”
Peter van Hardenberg
That loop, research to classroom and back again, is what makes this more than a product launch. The classroom is where the pretty assumptions go to get stress-tested. And we'll be candid: Backstitch is still in alpha. There are real bugs, and it's a team of two. Peter describes Paul's original prototype as
a woolly, barely strung-together prototype, with obvious potential, that totally blew up in your face if you looked at it wrong.
Peter van Hardenberg
That "blew up if you looked at it wrong" prototype is now real software running in real classrooms, with a Godot Asset Store release on the way so anyone can drop it into a project. Not bad for something that started out as a hunch and a hat joke.
If you'd rather see it than read about it, our Loom Lounge demo episode walks through the whole thing live with the team.
Try Backstitch with your learners
We've spent years watching real creative potential get stuck behind tools that were never designed for the people using them. Version control is just one example. The pattern's everywhere: onboarding that assumes you already know things, interfaces that reward experts and punish the curious, software that puts its own needs ahead of yours. Backstitch is us pushing back, and trying to prove it can go another way, something that works for a nervous beginner and a grizzled pro alike, where owning your own work is the default and the friction drops without the power going with it.
If you're an educator, a facilitator, a homeschooler, or anyone in the business of supporting learners in Godot, we'd genuinely love for you to try it and tell us what's missing. The team means it about the feedback. You say "this is broken" or "I wish it did this," and there's a real chance it shows up.
Try Backstitch at backstitch.dev, documentation, getting started guides, and a link to join the Discord where you can share feedback directly with the developers.
Watch the full conversation, the panel discussion this article is based on goes deeper on the research, the design decisions, and what it felt like to see it working in a classroom for the first time.
See it in action, our Loom Lounge episode walks through a live demo of the tool with the team.
Explore our programs, if you're an educator or organization interested in how Backstitch fits into game-based learning at Endless Access, we'd love to talk.
