EP07 - Figma Collaboration

How Figma enables 100 people to edit the same file. Learn about Operational Transforms (OT), CRDT-inspired logic, WebSocket real-time sync, and C++/WebAssembly rendering engine.

Tweet coming soon

This should be chaos. My browser should crash.

How? How is this not just a pile of digital spaghetti?

You're thinking about this with 2005-era technology. But the secret sauce here isn't as magic as it looks.

Wasn't Google Docs the first with this multiplayer thing? But this feels... faster.

Docs uses **Operational Transforms**. Figma does too—just with some modern tweaks. In both, the server is the strict rule-keeper for how changes get merged.

People online keep claiming Figma uses full CRDTs, but the real story is messier.

Both edits fly to the server. Whoever's edit arrives first, the server rewrites the second so it fits the new version—this is what an Operational Transform does. The OT server is the traffic cop.

Docs, Figma—they both have a central server to mediate ops and ensure everyone ends up with the same state, even if your changes collide or arrive out of order.

So if the server hiccups or I go offline, game over?

Mostly not. If you're offline, your changes queue up and get retried when you reconnect—but the server is always the decider. Docs and Figma both do this. The myth that OT can't handle offline is overblown.

Figma *does* use some CRDT-inspired logic for certain properties—like letting the latest color change 'win'—but for position, structure, or coordinating complex edits? The server still transforms and sequences.

If you read Figma's own posts, they say: 'pure CRDT would be way more complicated for visual data.' So, they use OT with a few CRDT flavors, not pure CRDTs.

CRDT would mean you and I both yell out our changes, and it doesn't matter who hears which command when—the model always converges.

Figma, in practice, wants you to tell the foreman first. Then he tells everyone else in a synchronized order.

Last-write-wins is real for color and similar things. Whichever timestamp is later, that's the color. But the server still tracks the actual sequence—no full Wild West here. The rule is 'baked in', but the server is the arbiter.

So every move is a command—id, property, timestamp—but if two land at the same time, the server decides?

Yep. Your client and mine can get ops in different orders briefly, but in the end, we all apply the ops as sorted by the server's sequence, which acts as the source of truth. Offline edits get replayed—no magic, but it works.

So it's not peer-to-peer or serverless, but if I drop connection, my changes will sync up later?

How do you send all these changes so quickly? Feels like I'm seeing everyone in real time.

WebSockets. Unlike HTTP polling (slow, like sending postcards), WebSockets keep a persistent connection open—like a live tube. Edits and cursors stream instantly.

This file is massive. Any other website, my fan would be blasting.

That's because Figma's core is a C++ engine, compiled to WebAssembly. Basically, a game engine disguised as a creative tool. That's what lets it chew through these huge files.

So... hybrid OT plus a few CRDT tricks, streaming changes over WebSockets, and a C++ engine in the browser. That's how Figma handles teams at scale?

Pretty much. They didn't reinvent multiplayer editing, but they scaled it for design—and with enough engineering flex to make it look like magic.