Beyond Git: Real-Time Version Control for Godot – Lilith Duncan GodotCon 2026 Talk Deep Dive

Key Takeaways

• Git merge conflicts on Godot .tscn files hit 37% — not because developers are bad at merging, but because Git’s line-based diff model fundamentally doesn’t match Godot’s structured scene tree serialization.
• Backstitch’s core insight is to eliminate conflicts, not improve diffing — using Operational Transform and scene-tree-aware conflict domain isolation to enable true real-time collaborative editing.
• Real-time VCS doesn’t mean abandoning Git — Backstitch sits as an acceleration layer on top of Git, with a bridge that still pushes commits to GitHub. Your CI/CD pipeline doesn’t break.
• Community skepticism on HN and Reddit centers on latency tolerance and state explosion — both issues were addressed in the talk, but the documentation is, frankly, garbage on these parts right now.
• Alpha stage, not production-ready — but for indie teams and small prototypes, the efficiency gains are real. Our team used it for a week and couldn’t go back to pure Git.

Introduction: The Nail in Git’s Coffin is Godot’s Scene Tree

I’ll be honest: before watching Lilith Duncan’s GodotCon 2026 talk, I dismissed “real-time version control” as a solution in search of a problem. Git has worked for fifteen years. Merge conflicts are an annoyance you deal with. Then last month, three people on our team modified the same level_03.tscn file simultaneously. Git exploded. Conflict markers littered the entire scene tree node path structure. Manual resolution took nearly two hours. I had that exhausted “why hasn’t this been replaced yet” look on my face.

Then I watched this talk. 57 points on Hacker News, only 3 comments — but those comments were from DevOps veterans discussing real technical details, not the usual “another person reinventing the wheel” cynicism. That told me something was actually here.

Lilith Duncan and Nikita Zatkovich’s core argument is deceptively simple: Git’s line-based text diff model is fundamentally wrong for Godot’s .tscn and .res structured binary-ish formats. It’s not that Git is bad. It’s that Git is the wrong tool for this specific job.

1. Problem Anatomy: Why Git is a Disaster for Godot Projects

1.1 Scene File Merges Aren’t “Merges”, They’re “Guessing Games”

Let’s look at a typical .tscn conflict. You and a colleague modify the same scene:

# Your change: Added a Sprite2D child under root
# Colleague's change: Added a Label child under root
# Git's merge result:
<<<<<<< HEAD
[node name="Sprite2D" type="Sprite2D" parent="."]
=======
[node name="Label" type="Label" parent="."]
>>>>>>> branch

Looks simple? No. When the scene tree goes three levels deep, has 50+ nodes, each with a dozen properties (position, rotation, scale, material override…), Git’s line-level conflict markers turn the file into an unreadable mess. You can’t tell which conflicts are real logical conflicts and which are Git guessing wrong.

Lilith cited a statistic in her talk: Git merge conflict rates on .tscn files are approximately 37% higher than on plain text code files. This came from their analysis of the Godot open-source repository’s commit history. Worse, about 60% of those conflicts are “false conflicts” — two developers modified completely different nodes, but Git’s diff granularity is line-based, and line numbers shift whenever any node is added or removed, making Git think the same line has a conflict.

1.2 The Binary Resource Version Control Void

Godot’s resource system (.res, .tres, .import) is essentially serialized Variant data. .import files contain import configuration, compression parameters, target platform settings. Two developers modifying compression quality on the same player.png.import file? Git gives you an unreadable conflict block — these files aren’t designed for human consumption.

We hit this exact issue: our artist was tweaking texture import settings while another team member changed the import path for the same resource. Git merged, the resource reference broke, and the scene crashed on load. In a pure Git workflow, this is nearly unsolvable without rigid “file locking” — which defeats the purpose of distributed version control.

1.3 The Core Insight from the Talk

One line from Lilith stuck with me:

“We keep trying to make Git work for Godot by adding better diff tools. That’s like trying to fix a broken engine by polishing the dashboard. The problem is fundamental.”

Her logical chain:

1. Godot’s scene tree isn’t text — it’s a graph structure
2. Graph structures can’t be merged with line-based diffing; they need Operational Transform
3. Real-time synchronization isn’t a “nice-to-have” feature — it’s the only viable path to solving graph structure merging, because it lets conflicts be detected and resolved the moment they happen, not when you commit

2. Backstitch Architecture: Not a Git Replacement, a Git Accelerator

2.1 High-Level Architecture

graph TB
    subgraph "Godot Editor Client"
        A[Godot Editor Plugin] --> B[Scene Tree Operation Listener]
        B --> C[Operation Serializer]
        C --> D[WebSocket Client]
    end
    
    subgraph "Backstitch Server"
        D --> E[Operation Receiver]
        E --> F[Conflict Detection Engine]
        F --> G[OT Transformation Engine]
        G --> H[Scene State Snapshot Manager]
        H --> I[Persistent Storage SQLite/Postgres]
        I --> J[Git Bridge]
    end
    
    subgraph "Traditional Version Control"
        J --> K[Git Repository]
        K --> L[GitHub/GitLab]
    end
    
    style A fill:#4a90d9,color:#fff
    style E fill:#e74c3c,color:#fff
    style J fill:#27ae60,color:#fff
    style K fill:#95a5a6,color:#fff

2.2 Operational Transform: How It Works

This is Backstitch’s core technical innovation. It doesn’t sync file states — it syncs operations.

Example:

• Developer A: Inserts a Goblin node of type CharacterBody2D under Level1/root/Enemies
• Developer B: Inserts a HealthBar node of type Control under Level1/root/UI

In Git, both operations change file content. If they happen on “adjacent lines,” Git screams conflict. In Backstitch, these operations serialize as:

{
  "type": "node_insert",
  "target_path": "Level1/root/Enemies",
  "node_data": {
    "name": "Goblin",
    "type": "CharacterBody2D",
    "properties": {
      "position": {"x": 100, "y": 200}
    }
  },
  "timestamp": 1712567890,
  "client_id": "dev_a_01"
}

{
  "type": "node_insert",
  "target_path": "Level1/root/UI",
  "node_data": {
    "name": "HealthBar",
    "type": "Control",
    "properties": {
      "anchor_left": 0.0,
      "anchor_top": 0.0
    }
  },
  "timestamp": 1712567891,
  "client_id": "dev_b_02"
}

Backstitch’s OT engine checks dependency relationships between these operations. Since target_path differs (one under Enemies, the other under UI), they’re commutative — order of application doesn’t matter. Both are accepted simultaneously. No conflict.

Real conflicts only trigger when two operations modify the same property at the same path. Three resolution strategies exist:

Lilith emphasized: Over 80% of operation conflicts can be auto-resolved via LWW or operation merging. Only ~20% require human intervention. Compare that to Git’s 37% conflict rate.

2.3 Scene State Snapshot Manager

Real-time sync has a classic problem: state explosion. Every operation gets recorded. Over time, replaying all operations to reconstruct scene state becomes painfully slow.

Backstitch’s solution is periodic scene state snapshots. By default, every 1000 operations or every 30 minutes (whichever comes first), the server generates a full snapshot:

# backstitch_server_config.yaml
snapshot:
  interval_operations: 1000
  interval_seconds: 1800
  compression: zstd
  storage_path: /var/backstitch/snapshots/
  
  snapshot_retention:
    hourly: 48
    daily: 30
    monthly: 12

When a new client joins, it loads the latest snapshot and applies only the incremental operations after it. This drops join overhead from O(n) to O(1).

2.4 The Git Bridge: Your CI/CD Stays Intact

Many “real-time VCS” tools make a fatal mistake: they tightly couple real-time sync with version control, breaking existing CI/CD pipelines.

Backstitch’s Git Bridge solves this. It’s a bidirectional sync proxy:

Backstitch Server <-> Git Bridge <-> Git Repository (GitHub/GitLab)

Workflow:

1. Developers collaborate in real-time via Backstitch inside the Godot editor
2. When the team decides to “commit” (e.g., finishing a feature), Backstitch generates a merged scene state
3. The Git Bridge serializes this state into standard .tscn and .res files
4. It executes git commit and git push

Reverse direction (pulling from Git):

1. Git Bridge detects new commits
2. Deserializes files into scene operations
3. Injects those operations into Backstitch’s operation stream — all online clients get real-time updates

This means: Backstitch doesn’t change your Git workflow. It’s an acceleration layer on top. Your CI/CD, code review processes, release tags — everything stays the same.

3. Deployment and Configuration: From Zero to Backstitch Server

3.1 Server-Side Deployment

Backstitch Server is written in Rust, compiles to a single binary:

wget https://backstitch.dev/downloads/v0.3.0/backstitch-server-linux-x86_64.tar.gz
tar -xzf backstitch-server-linux-x86_64.tar.gz

mkdir -p /etc/backstitch/
./backstitch-server init > /etc/backstitch/config.yaml

Core config.yaml:

server:
  host: "0.0.0.0"
  port: 7890
  tls:
    enabled: true
    cert_file: /etc/letsencrypt/live/yourdomain.com/fullchain.pem
    key_file: /etc/letsencrypt/live/yourdomain.com/privkey.pem

storage:
  type: postgres
  connection_string: "postgres://backstitch:password@localhost:5432/backstitch"
  pool_size: 20

auth:
  provider: jwt
  jwt_secret: "your-secret-key-at-least-32-chars"

audit:
  retention_days: 90
  enable_operation_replay: true

projects:
  - name: "my-godot-game"
    scene_patterns:
      - "scenes/**/*.tscn"
      - "resources/**/*.res"
    exclude_patterns:
      - ".git/**"
      - ".godot/**"
      - "*.import"

Start with systemd:

sudo tee /etc/systemd/system/backstitch.service << EOF
[Unit]
Description=Backstitch Real-Time Version Control Server
After=network.target postgresql.service

[Service]
ExecStart=/usr/local/bin/backstitch-server --config /etc/backstitch/config.yaml
User=backstitch
Group=backstitch
Restart=always
RestartSec=5
MemoryMax=2G

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl enable backstitch
sudo systemctl start backstitch

3.2 Godot Editor Plugin Setup

Inside your Godot project, add to project.godot:

[backstitch]
server_url="wss://your-backstitch-server.com:7890"
project_id="my-godot-game"
auto_connect=true
sync_interval_ms=100

The plugin adds a Backstitch panel to the editor showing connection status, online members, and a real-time operation log.

3.3 Performance and Security Considerations

Security gotchas:

• All communication must be WSS. Plaintext WS exposes your scene data on the wire.
• JWT secret must be 32+ characters. Don’t hardcode it. Use environment variables.
• For teams >10 people, enable authentication. Otherwise anyone can connect and modify your scenes.

4. Community Feedback and Our Real-World Experience

4.1 Hacker News Technical Discussion

The HN thread had 57 points and 3 comments — low volume but high signal:

“The operational transform approach makes a lot of sense for scene trees. But I wonder about the network latency tolerance—if someone has 300ms ping, does the whole team feel it?”

This is Backstitch’s biggest current weakness. Lilith mentioned operation buffering: each client maintains a local buffer of unacknowledged operations. Operations apply locally immediately (instant feedback), then get sent asynchronously. If the server rejects an operation (conflict), the client rolls back and re-applies. That rollback can cause visual “flashing” — nodes disappearing and reappearing. At 300ms latency, this flashing is very noticeable.

Our cross-ocean team (one in China, one in the US) hit this. The fix: bump sync_interval_ms to 300 and enable operation batching — packing multiple short-interval operations into a single batch to reduce round trips.

“How does this handle the ‘state explosion’ problem? If you record every single mouse drag, the operation log is going to be massive.”

Backstitch deduplicates and compresses operations. Dragging a Sprite for 2 seconds might generate 60 property_set operations (X and Y changing together). Backstitch detects this as a continuous stream and retains only start state, end state, and interpolation curve — not 60 individual operations. Compression ratio: typically 20:1 to 50:1.

4.2 Reddit Feedback

Reddit discussions on r/godot and r/gameenginedevs raised several points:

• Concern about dedicated server requirements — small indie teams don’t want DevOps overhead. Lilith’s response: cloud-hosted version is on the roadmap (waitlist on backstitch.dev).
• Fear that real-time sync encourages “chaos editing” — without Git’s pre-commit review cycle. Backstitch has an operation review mode that requires approval before broadcasting, but this kills the real-time advantage.
• Sharpest criticism from an ex-Unity developer: Backstitch is solving a problem caused by Godot’s scene file format design. If Godot switched to programmatic scene generation (like Unreal’s Blueprint internals), Git might work fine. Lilith’s response: “Changing Godot’s serialization format is a breaking change. Backstitch solves today’s problem without breaking the ecosystem.”

4.3 Our Team’s Measured Results

We tested Backstitch on a mid-sized Godot project (~200 scenes, 800 resources, 5-person team) for one week:

But it wasn’t all roses. We hit several issues:

1. Operation log bloat: After a day of heavy collaboration, the operation log hit 1.2GB. Snapshots help, but disk planning is essential.
2. Plugin stability: The Godot editor plugin crashes occasionally on Godot 4.3, especially when rapidly switching between multiple open scenes. Known issue, v0.4.0 fix incoming.
3. Documentation is garbage: I agree with the HN comment. Backstitch’s docs are basically a README and a few config examples. Advanced features like operation review mode and custom OT strategies are undocumented — you have to read the source.

5. Best Practices Summary Table

6. FAQ

Q: Does Backstitch support all Godot 4.x versions?

Currently, Backstitch v0.3.0 officially supports Godot 4.2, 4.3, and 4.4 beta. Godot 4.1 and earlier are untested. The plugin uses GDExtension and is theoretically compatible with all 4.x versions, but API differences in scene tree handling may cause serialization issues.

Q: How does Backstitch’s OT engine handle nested node deletion?

This is the most complex scenario. When a node is deleted, all children are cascaded. If another developer modified a child node’s property simultaneously, the OT engine uses tombstone markers — the deleted node retains an empty reference until all conflicting operations are resolved. This prevents “I deleted the parent but you’re modifying the child” reference errors.

Q: Can Backstitch work with Git LFS?

Yes. The Git Bridge doesn’t touch LFS management. Large files (textures, audio, models) still go through Git LFS. Backstitch only syncs scene trees and resource configuration files (.tscn, .res, .tres). Configure scene_patterns to exclude *.png, *.wav, etc.

Q: What happens if the server crashes? Do I lose local edits?

No. The Godot editor plugin maintains a local operation log (default path: project://.backstitch/local_oplog.json). When the server reconnects, the plugin replays unsynchronized operations. If the server is down for >30 minutes, the plugin prompts the user to save local modifications as .tscn backup files — an escape hatch back to pure Git workflow.

Q: How is operation ordering guaranteed?

Backstitch uses Lamport logical clocks. Every operation carries a (client_id, logical_timestamp) pair. When timestamps match, ordering falls back to client_id lexicographic sorting. This guarantees a consistent total order across all clients without requiring a global clock.

7. References and Community Insights

• Backstitch Official Site — Download binaries and plugin
• Lilith Duncan GodotCon 2026 Talk Video — 57-point HN story, primary content source
• GodotCon 2026 Full Schedule — Includes Backstitch workshop and live demo
• Backstitch GitHub Repository — Source code and issue tracker
• HN Discussion Thread — Community skepticism and technical feedback
• Reddit r/godot Discussion — Real-world deployment stories and pitfalls