Why Goodnotes Betting on Swift + WebAssembly Changes Everything for Cross-Platform Development

Remember when "web app" meant "compromised experience"? Goodnotes is rewriting that narrative.

The note-taking powerhouse — Apple's iPad App of the Year in 2022 — just dropped a technical deep-dive that makes developers sit up and pay attention. They took their existing Swift codebase, the same millions of lines powering their iOS app, and got it running seamlessly in web browsers through WebAssembly. Not a port. Not a rewrite. The actual same code.

The real win? Behavioral consistency.

Here's what makes this story compelling beyond the technical achievement. When you draw a note on your iPad and later open that same document on the web, you see exactly the same curves, the same pressure sensitivity, the same ink flow. That's not because Goodnotes carefully reimplemented the same algorithms twice — it's because it's literally the same Swift code running on both platforms.

Think about what that means for development velocity. Every bug fix, every performance improvement, every new feature benefits all users simultaneously. No more "web version has this quirk but iOS is smooth." No more maintaining parallel codebases that inevitably drift apart.

Numbers don't lie — but they do tell a story.

The architecture Goodnotes built separates platform-specific UI from shared business logic, allowing native capabilities while maintaining consistency. Their shared core includes:

• A content rendering engine (Metal on iOS, WebGL on the web)
• Business logic layer handling document modeling, handwriting recognition, and indexing
• Core view models managing tool interactions and gestures

The results? Out of a 2.2 million line web Swift codebase, 1.47 million lines are shared with iOS. That's 66% code reuse — and it represents the most critical parts of the application.

But this wasn't a simple "compile and ship" process.

Goodnotes had to solve some interesting problems. Their WebAssembly binary comes in at roughly 50 MB, compressing to 12 MB with Brotli — manageable with proper caching strategies using Service Workers. They had to migrate from libdispatch to Swift's async/await and actors for cross-platform concurrency compatibility. Code assuming 64-bit integers needed updates to explicitly use Int64 on wasm32 targets.

These aren't dealbreakers — they're the kind of engineering decisions every serious cross-platform project has to make. The difference is that Goodnotes did the hard work upfront so their core logic stays clean and shareable.

What does this mean for you?

SwiftWasm isn't a niche experiment anymore. Goodnotes proved it's viable for "complex, performance-critical web applications" — their words, after two years of development and over two years in production.

For developers building performance-sensitive applications, this opens a legitimate path to web deployment without abandoning native code quality. For product teams, it offers the promise of one codebase, one source of truth, consistent behavior everywhere.

We're watching a significant shift in how web applications can be built. The days of choosing between native performance and cross-platform reach might finally be over — and Swift + WebAssembly is leading that charge.