Latest / The CTO Podcast with Fexingo: Technical Leadership, Architecture, and Engineering Org / How Adobe Rebuilt Photoshop for the Browser
Transcript
- Lucas: If these conversations are useful for what you are building or running — and I know a lot of you are in the thick of modernising old systems — today's story is going to feel very familiar. Adobe just finished shipping Photoshop into the browser. The full thing. Not a stripped-down preview — the actual thirty-five-million-line C++ codebase, running in a tab. Luna: Wait — the whole thing? Like, layers, masks, curves, all of it? Lucas: All of it. They call it Photoshop on the Web, and it's been a four-year project internally. The team started with a simple question: could they recompile their C++ code into WebAssembly and get pixel-accurate output on any modern browser? Luna: And the answer was yes — but I'm guessing the path was anything but simple. Lucas: Exactly right. The first hurdle is just the sheer size of the codebase. Photoshop has been in development since the late 80s. There are parts of the code that predate the internet. So the engineering team — led by a group inside Adobe's Web Platform org — had to decide what to port and what to leave behind. Luna: What did they leave behind? I imagine some of the plug-in architecture must have been tough. Lucas: They deliberately left out native plug-ins that rely on operating system specific APIs. Those require direct access to file systems or system-level hooks that browsers simply don't provide. Instead, they built a new plug-in model using WebExtensions, but that's still rolling out. For the initial launch, it's the core image-editing engine — layers, selections, brushes, adjustment layers — basically everything a professional needs for a typical editing session. Luna: So how does the architecture actually work? Are they running the same binary inside the browser? Lucas: Almost. They used Emscripten to compile their C++ into WebAssembly. But WebAssembly alone isn't enough — you need access to the GPU for rendering, and you need shared memory for the multi-threaded operations that Photoshop relies on. So they also used SharedArrayBuffer for threading, and WebGL 2.0 for the graphics pipeline. The entire thing runs client-side — no server-side rendering, no streaming pixels. Luna: SharedArrayBuffer — that's the one that requires cross-origin isolation headers, right? So they had to configure their entire hosting infrastructure to opt into that. Lucas: Correct. That was actually a bigger organizational challenge than the code. Every asset on the page — every font, every image, every script — had to be served from an origin that set the proper COOP and COEP headers. Adobe had to audit their entire CDN pipeline. If any third-party script wasn't compatible, the whole feature would break. Luna: I remember a few years ago, Firefox actually disabled SharedArrayBuffer by default for exactly those security concerns. Did that affect their decision at all? Lucas: It did. They had to work closely with Mozilla and Google to ensure compatibility. And they built a fallback: if SharedArrayBuffer isn't available, the app falls back to single-threaded mode, which is slower but still functional. That's a smart architectural pattern — degrade gracefully rather than fail entirely. Luna: Alright, so the engine is there. But how does the user interface work? Photoshop's desktop UI is notoriously complex — dozens of panels, tool options, keyboard shortcuts. Lucas: The UI is rendered using standard web technologies — HTML, CSS, JavaScript — with the C++ engine compositing the actual image canvas. So the UI layer is decoupled from the image processing layer. That's actually a huge advantage: the desktop team can update the UI independently of the engine. And because the UI is web-native, Adobe can iterate on it much faster. Luna: That also means they can ship new features without waiting for a full desktop release — continuous deployment for a thirty-year-old product. Lucas: Exactly. And that's the real strategic play here. Adobe's long-term goal is to unify the codebase across platforms. If they can get the core engine running in the browser, they can eventually reuse that same engine for iPad, for Android, for any platform that supports WebAssembly. The desktop version isn't going away, but the web version becomes the new development target. Luna: Let's talk about performance. WebAssembly is still slower than native code — maybe ten to twenty percent overhead, depending on the workload. For a tool like Photoshop, where every millisecond counts, how did they close the gap? Lucas: They used several techniques. One was SIMD — single instruction multiple data — which WebAssembly now supports. That gave them a big boost on pixel operations like blur and color conversion. Another was offloading heavy computation to Web Workers, which are essentially background threads. And they spent a lot of time optimizing their memory allocation patterns — because WebAssembly has a linear memory model, garbage collection can be tricky if you're not careful. Luna: And yet, even with all that, some operations are probably slower than the native app. Did they have to make any concessions on quality? Lucas: They claim pixel-perfect output — meaning the same algorithm produces exactly the same pixels as the desktop version. But speed-wise, yes, some operations are slower, especially when working on very large documents — say, a hundred layers at eight thousand pixels each. For the typical use case, though, users report it feels responsive. Adobe's benchmark showed that the web version is within twenty to thirty percent of desktop performance for most single-threaded operations. Luna: That's impressive. How did they organize the engineering team to pull this off? Because this isn't just a technical problem — it's a people and process problem too. Lucas: They created a dedicated 'Web Platform' team within the larger Photoshop engineering org. That team owns the WebAssembly build, the browser-specific APIs, and the web UI. The desktop teams continue to own the core engine and feature code. So the Web Platform team essentially acts as a translation layer — porting features as the desktop teams ship them, but also pushing changes back into the common C++ codebase when needed. Luna: That's a really smart structure. It avoids the 'fork and forget' problem where the web version falls behind. Lucas: Exactly. And they built automated testing that runs the same image-processing pipeline on both desktop and web, comparing the output pixel by pixel. If a change on the desktop side breaks the web build, they catch it in CI. That gives the desktop teams confidence to refactor without worrying about breaking the web port. Luna: So what's next? Are they planning to bring all of Creative Cloud to the browser? Lucas: That seems to be the direction. Illustrator, Lightroom, and Premiere Pro are all candidates, though each has its own challenges. Video editing is particularly hard because of the real-time requirements. But the Photoshop project has proven the concept — and more importantly, it's proven the engineering model. Luna: If this kind of deep dive is useful to you, it's worth mentioning that the way we keep this podcast ad-free and focused is through listener support. If you value episodes like this, you can help us keep going at buy me a coffee dot com slash fexingo. No pressure, just a way to say thanks. Lucas: Yeah, that genuinely helps us keep the conversations going. Alright, back to the architecture. One detail I love is how they handled the color management system — because browsers don't have a native color management API that matches Adobe's proprietary engine. Luna: Right, color spaces — sRGB, Adobe RGB, ProPhoto RGB. That's a huge deal for photographers. Lucas: They had to bring their own color management library into WebAssembly. That's millions of lines of code just for color transforms. And they had to ensure that the browser's rendering pipeline doesn't override their color data. So they output raw pixel buffers and let the browser composite them as-is, bypassing any automatic color correction. Luna: What about the user's local fonts? Photoshop on desktop scans the system font folder. The browser can't do that — at least not directly. Lucas: They used the Font Access API, which is still experimental but available in Chromium-based browsers. That lets the web app request a list of locally installed fonts and load them. For browsers that don't support it, they fall back to Adobe Fonts — their cloud font service. Luna: So the web version is actually more limited on font availability unless you're on Chrome or Edge. Lucas: For now, yes. But Adobe is betting that browser APIs will catch up. And honestly, the web version is not meant to replace the desktop app for everyone — it's for collaboration, for quick edits, for people who don't have a high-end machine. Adobe sees it as an expansion of the user base, not a replacement. Luna: That's a good way to frame it. So what's the one lesson you'd take from this project if you're a CTO considering a similar migration? Lucas: Start with a clear boundary. Don't try to port everything at once. Adobe chose the core editing engine — the part that's most stable and most performance-sensitive — and built a web shell around it. Then they incrementally added features. The other lesson is to invest in your build infrastructure early. The cross-compilation pipeline alone took months to get right. But once it was solid, it became an asset. Luna: I think the organizational structure is the part that resonates most. The Web Platform team model — that's something any large org can replicate. Lucas: Absolutely. And the fact that they kept the desktop teams fully in the loop meant there was no us versus them dynamic. The web team contributed optimizations back to the C++ codebase that actually benefited the desktop app too — better memory management, faster pixel pipelines. So it became a rising-tide-lifts-all-boats situation. Luna: Alright, I think that's a solid takeaway. Next episode, I want to look at how Figma handled their multiplayer engine — but I think we've got a good picture of what it takes to move a legacy giant to the browser. Lucas: Yeah, and if you want to try it yourself, Photoshop on the Web is now available to all Creative Cloud subscribers. Just go to photoshop.adobe.com and log in. No installation required.