SkiaSharp for .NET

If you've built a .NET app that draws anything — text, geometry, images, a custom control that needed just a little more than what the platform gave you — you've almost certainly touched SkiaSharp. Maybe you knew it. Maybe you didn't. Either way, it's been quietly doing the heavy lifting under some of the most-used UI stacks in the .NET ecosystem for over a decade. And with SkiaSharp 4.0 now stable, it just took its biggest step forward in years.

Let's unpack why SkiaSharp exists, why it's earned its spot as the rendering backbone of modern .NET, and what its newfound co-maintenance model with Uno Platform means for where it's headed.

Cross-Platform Rendering Needs

A Bit of History on Drawing in .NET

.NET wasn't always the cross-platform citizen it is today. Rewind to the early days, and .NET — and drawing in .NET — was a Windows-centric story through and through.

Windows Forms and WPF gave developers a way to build applications with a GUI, and they did the job well — but they were built with one platform in mind. As Jonathan Dick, .NET MAUI Engineering Lead at Microsoft, put it plainly on our SkiaSharp 4.0 launch event: those early APIs "were not bad — they did the job," but they were "fairly Windows-centric." That's GDI+ for you: functional, foundational even, but tied to a specific platform's plumbing.

Then there's System.Drawing — the managed wrapper around GDI+ that a generation of .NET developers reached for by default. It worked great, right up until you tried to run it somewhere that wasn't Windows. And when Win2D came along later to give UWP developers a more modern, hardware-accelerated drawing API, it solved real problems — but again, for one part of the Windows ecosystem.

The pattern here isn't hard to spot: every time .NET wanted to draw something custom, the answer was a new Windows-flavored API. Great tools, wrong shape for a world where .NET was about to run everywhere.

The Gap SkiaSharp Fills

That gap became impossible to ignore once Mono developers started pushing .NET onto iOS and Android — genuinely new territory at the time. Dick traces the origin story back to Miguel de Icaza: what if, instead of reinventing a drawing API for every platform, .NET took the graphics library Google already built to power Android and Chromium — Skia — and made it accessible to .NET developers directly?

That's the gap SkiaSharp fills. One rendering API. Every platform .NET touches. No lowest-common-denominator compromises, no platform-specific quirks bleeding into your drawing code. If .NET runs there, SkiaSharp can draw there — consistently.

Why SkiaSharp Shines

Built on Skia, Battle-Tested at Scale

SkiaSharp isn't some bespoke rendering engine dreamed up in isolation — it's a .NET binding over Skia, the same open-source graphics engine that powers Chrome, ChromeOS, and Android. When Flutter needed a rendering engine, it started with Skia too. That's not a coincidence — that's a signal. A graphics engine trusted by some of the largest, most demanding software on the planet is exactly the kind of dependency you want underneath your .NET apps.

Pixel-Perfect, Everywhere

Here's the thing about drawing APIs — even on a single OS, they don't agree with each other. GDI+ on Windows behaves differently than DirectX on the very same machine. Different methods, different pipelines, different messaging — despite being the "same" platform. Now multiply that inconsistency across iOS, Android, Windows, macOS, Linux, and the web.

SkiaSharp erases that problem. Whether you're rendering on an Intel Mac or an Apple Silicon one, an Android phone or a Linux desktop — SkiaSharp handles the differences under the hood so your output looks the same everywhere. As Dick describes it, that's the whole point: you shouldn't have to worry about GPU differences as a developer. The library knows how to get you the result you want, no matter where "there" is.

GPU-Accelerated for Real Performance

SkiaSharp doesn't just run everywhere — it runs fast everywhere, using hardware acceleration wherever it's available. Dick's analogy on this nails it: it's like comparing a four-cylinder engine to an eight-cylinder one. You might get a different level of horsepower depending on the hardware underneath, but that's the engine talking, not the library. SkiaSharp is going to use what you give it, as efficiently as it can.

Active Maintenance, Genuinely Alive

A rendering library is only as good as its upkeep, and SkiaSharp is nearing its 10-year mark with more active investment behind it than ever — engine upgrades, security hardening, new capabilities shipping on a real cadence. This isn't legacy code on life support. It's a living project with multiple organizations actively pushing it forward.

How .NET MAUI Leverages SkiaSharp

.NET MAUI's philosophy has always been to abstract over native UI — a solid foundation, but one that inevitably runs into the same wall Windows Forms and WPF did: sometimes you need to draw something custom. MAUI's answer is MAUI Graphics, an abstraction layer that, by design, lets you plug SkiaSharp in as a backend.

Dick frames the tradeoff well: you get to choose "pixel-near-perfect" using the native drawing engine per platform, or true "pixel-perfect" by dropping in SkiaSharp — useful when you're rendering something like a barcode that has zero tolerance for approximation. MAUI also leans on SkiaSharp at build time, compositing app icons and assets across the different layering requirements of Android and iOS. It's threaded through the framework in ways most developers never see.

Uno Platform Is All In on SkiaSharp

For Uno Platform, SkiaSharp isn't an optional backend — it's foundational. Our promise has always been that a single C# and XAML codebase produces pixel-accurate applications across every platform target: Windows, macOS, Linux, iOS, Android, and WebAssembly. SkiaSharp is the rendering foundation that makes that promise real.

And it's not just the classic Uno Platform stack. With Uno Platform Studio 3.0, we're enabling agentic workflows across web, desktop, and any IDE or CLI — go from a prompt to a running cross-platform .NET app, right in your browser. AI can scaffold the app, iterate the logic, refine the structure. But every pixel the user actually sees, every transition, every rendered surface — that's SkiaSharp. It's the layer that makes "runs everywhere" mean something visually, not just structurally.

Maturity with SkiaSharp 4.0

A Big Milestone

SkiaSharp 4.148.0 is the first stable release of SkiaSharp v4 — and it's not a minor version bump. It brings the native Skia engine current through milestone m148 (two and a half years and 28 milestones of upstream improvements), a cleaner and more correct API with a reworked object lifecycle that quietly closes a whole class of use-after-free crashes, variable font support, color font palettes, animated WebP encoding, and rendering that's up to 24% faster on the GPU-accelerated backend. For Uno Platform apps specifically, early testing is showing improvements of up to 30%.

Just as important: SkiaSharp now ships on a predictable cadence, tracking upstream Skia's Stable and Beta channels. No more guessing when the next meaningful update lands.

.NET and Uno Platform, Co-Maintaining Together

Here's the part that changes the story going forward — Uno Platform is now a formal co-maintainer of SkiaSharp, alongside the .NET team at Microsoft. That's not a branding exercise. It means Uno Platform's engineering team has a direct, ongoing role in SkiaSharp's release process, triage, and direction — helping stabilize APIs, land variable font support, and benchmark performance. Issues that affect Uno Platform users — WebAssembly rendering behavior, performance regressions, API gaps — now have a team with deep context actively working on them, not waiting on someone else to get to them.

Hear from Jonathan Dick

We sat down with Jonathan Dick, .NET MAUI Engineering Lead at Microsoft, at our SkiaSharp 4.0 launch event to talk through exactly this history and where things go from here. Dick has watched SkiaSharp "start out from this pretty simple initial library and grow into what it has today" over close to a decade of work.

His read on where cross-platform rendering in .NET goes next? Bigger commitments, tighter collaboration, and a shared focus on making sure SkiaSharp gets "the right level of attention and care that it needs to live on — and not just live on, but really prosper." Watch the full conversation below:

See What's Possible with SkiaSharp

Talk is cheap — SkiaSharp is easy to try for yourself, and there's no shortage of ways to jump in:

• Get started fast at the official SkiaSharp site — docs, tutorials, and API reference all in one place.
• SkiaFiddle is your interactive SkiaSharp playground — write and run SkiaSharp code directly in your browser at the SkiaSharp fiddle. No install, no setup, just code and see results instantly.
• The Uno Platform WebAssembly gallery shows SkiaSharp rendering live, in the browser, powered by Uno Platform's Wasm renderer — check it out at the gallery.
• And if you want to see just how far this goes — Uno Platform 3.0 can spin up a full, running .NET app entirely in your browser, from a prompt, with AI. No install required. Every pixel of that app's UI? SkiaSharp.

That last one is worth sitting with for a second. We've gone from "a drawing API that solves a platform gap" to "the rendering layer underneath AI-generated .NET apps running live in a browser tab." That's a decade of evolution in one sentence.

Wrap Up

SkiaSharp isn't a niche library for developers who need "extra" drawing capability — it's foundational infrastructure that most of the .NET ecosystem already depends on, whether that dependency is visible or not. It solved a real gap: one consistent, GPU-accelerated, pixel-perfect rendering API across every platform .NET touches, built on a graphics engine already battle-tested at Google scale.

With SkiaSharp 4.0 now stable — and with Uno Platform and the .NET team at Microsoft co-maintaining it together — the future here is genuinely bright. Faster releases, a predictable cadence, closer collaboration, and a rendering foundation that's only getting stronger under the AI-native, agentic workflows reshaping how .NET apps get built. If you're building anything that needs to look right, everywhere, this is the layer to bet on.

Cheers developers! 🚀