However, no one one my design team likes it. I certainly don't. It's akin to having someone breathing over your shoulder as you're trying to work. And with design, especially, I tend to create a bunch of nonsense and "bad" designs before getting anywhere near a level worthy of sharing or even a team critique. Even if I don't care what others think of me or my skills, it's very disruptive to the creative process to know that someone is watching you.
In my experience, at least, there do not seem to be very many use cases for "multiplayer." I mean, even using Google Docs at the same time as someone else is jarring and disruptive in most cases.
Perhaps the only use case where we've actually liked having it is for a critique (especially when a teammate is remote) or a demo.
Personal preference aside, I think Figma is great. I still miss some things from Sketch, but overall Figma is a great tool. My team recently transitioned/is still transitioning from Sketch to Figma, and I can imagine that many other design teams will be making the same move too.
Versioning is hell, there are git-like solutions like Abstract or Cactus but aside from those solutions being half-baked, the need for versioning at all disappears with multiuser/multiplayer. You have one doc, one source of truth. When I work with other designers, PMs, copywriters, etc. Who all need to make edits for one reason or another, it because a nightmare really quickly.
The fact is 99% of the time, you'll be in the file alone. Just like Google Docs. But when you need it, it saves you a lot of time.
That said, we are all producers at my studio and we also respect each other's space. Everyone designs in some capacity and we're all very comfortable in our skin. We don't really "snoop" on each others work if we know it's not time for feedback or we're not co-designing. The only time I'd pop into someones file or artboard I know they are actively working in is if I need to quickly copy/paste something I know they have (little things like this are amazing). Speaking of co-design, this is my favorite part of Figma. A few days per week we dedicate time to co-design with another person, kind of like pair-programming. Generally we both already have a base level of work complete and we talk through it, then riff on each others ideas and work to come up with something new or solve problems in different ways. Working this way at least a few days per week has really paid off for us and it's quite fun. I also feel like I learn new design tricks or skills I wouldn't have if I wasn't working this way.
I feel like between using this feature in a pre-planned way and also having some unspoken rules/constraints around how we review each others work is all you need to do to make this less of an issue. Honestly I look at it the same as literally standing over someones shoulder. I would never do that unless invited, and even then I'd prefer to sit next to them and it be more collaborative. There is also the trick, which some people do at our studio, of simply working in a private file until you're ready to paste everything into the collaborate projects. It's as simple as a copy/paste and you have complete privacy if that's what you want. We purposely do this with most of our clients so they are not tempted to leave feedback before we're ready.
I'm curious why. I would've thought that the main advantage of Figma is the "online collaboration" aspect, but if you don't like that part, what is it that makes Figma better than Sketch?
Also since you can see the other person's cursor on your screen, you know when they're "watching" you. But in our case we don't really spend time scoping what each other is doing until one of us asks for help.
To echo what other commentators are saying regarding versioning, as someone who used to do Git, Plant.io, and Abstract to sync Sketch files, Figma removes this huge painful time-wasting part of our workflow.
Figma realized the same thing before starting the project:
> If anything, people hated the idea.
It seems they simply wanted to build this feature regardless of what the users think:
> But ultimately, we had to do it because it just felt wrong not to offer multiplayer as a tool on the web
Funny.
Maybe consider labeling the files that are in progress as such?
I've now gone fully the other direction and will open draft pull requests as soon as I start committing code, knowing that I have nothing to lose from doing so and often end up being saved time and with a better finished product sooner when someone whose intuition probably told them to peek at this particular piece of work for a reason.
TL;DR - You can get used to this and even grow to prefer it. That said, design is not engineering and I may simply have Stockholm Syndrome.
FWIW, here's how it's done for actual multiplayer games, especially the ones where latency is critical: https://gabrielgambetta.com/client-server-game-architecture.... Arguably, their software is more similar to a turn-based game, and formal correctness of the results is more desirable than "a smooth experience", as is the case for multiplayer games.
Figma needs to have very consistent, predictable resolution in order for users to trust it with business-critical documents, and it needs to allow users to operate offline for arbitrarily long periods without throwing their work away when they reconnect. This has to happen across multiple versions of the software, and across documents (e.g. when dependency libraries are republished).
If you want to see an example of how it works, check out my side project Doodledocs. I modified the Bugout library a bit for performance improvements, but my project is using its concept on how to spin up a serverless (i.e. not your servers but those of WebTorrent) P2P web app [2].
[1] https://github.com/chr15m/bugout
[2] Doodledocs is a collaborative doodling web app that I created as a sideproject, so it is just a bit related to Figma. I didn't make CRDTs yet, since I want a simple doodle environment for pencil/eraser (+ simple web annotation/image annotation).
Link: https://doodledocs.com (browsers tested: Chrome/laptop, Chrome/iPad, Safari/iPad).
I didn't mention P2P or edit my comment at any point, BTW.
http://fabiensanglard.net/quake3/network.php
It merges unacknowledged data into packets containing new information.
There's also GGPO which has been open sourced recently:
> The real-time collaborative editing feature that we’ve been working hard on over the past year is finally ready! Our implementation is called “multiplayer” since it was inspired by cooperative multiplayer games.
But real-time/collaborative editing (or "live editing") had already been a thing for years. It's weird that they felt the need to rename it and slap a cool backstory ("videogames!") on it.
Regardless of if this is for a "Game" or not, I find reading more about these things quite interesting.
It’s less useful out of the context of the presentation, but maybe this could help with your project:
https://www.slideshare.net/HunterLoftis1/making-sense-of-mul...
This is incredibly similar to the way we did multi-user simultaneous editing in https://Clara.io back in 2013/2014. It was also a tree-based OT-like system, but there was a few differences.
I also wonder if you guys studied how we did it...
A lot of folks were using it to add "Multiplayer" to our apps.
What's the current state of play with it?
So the parent company, Exocortex, pivoted towards 3D ecommerce and introduced the threekit.com brand aimed directly at that market.
It has been working okay: https://venturebeat.com/2019/01/10/threekit-raises-10-millio...
I could've sworn I've seen people on HN say there were tools that did real-time collaborative design before figma.
I'm certain they were aware of it. We had a signup from a Figma domain in 2015 and I emailed them about Precursor in 2016 before they had implemented multiplayer.
If you're wanting to use CRDT tools, I recommend two:
- https://github.com/automerge/automerge (immutable)
- https://github.com/amark/gun (mutable)
There's only a small handful of HNers who upvote OT/CRDT/sync/realtime database submissions. So by now everyone is tired of seeing him promote gun.js again and again without contributing any other relevant technical insights.
Which is a goddamn shame. There aren't that many others who have first hand experience implementing these systems successfully. The other regulars who always appear in these threads get upvoted to high heavens even if they aren't saying much because we value these first hand accounts so much (josephg for share.js, raphlinus for xi editor's crdt, etc). But unfortunately after seeing gun.js hundreds of times I still have no idea how it works and his code is completely unreadable.
I don't think he realizes that if he had just explained why gun.js is amazing in a relevant way, others would help promote gun.js for him.
@MarkNadal Sorry if this was too mean
It’s interesting to see this on HN at the same time as the GNU article about “Service as as Software Substitute”. I would have much more piece of mind that my personal or proprietary information is secure if I didn’t have to trust Figma. A peer-to-peer collaboration platform that I can run locally would be innovative and exciting.
I also did some work in that area several years ago which I refined over time into a sample app and a set of libraries: https://github.com/SocketCluster/ag-crud-sample#ag-crud-samp...
That sounds like a bad reason to implement you own mechanism. There are many valid reasons to design your own system (your requirements being different is the most common one), but “the state of the art is too complex” sounds like a good way to reinvent all the solutions to the technical problems the state of the art faced and end up with an equally complex solution in the end.
This isn't to dismiss the work exposed here, and the really pleasant write-up, though.
