Paint.NET now runs on Linux, and it took reverse-engineering an entire graphics API to make it happen.

Rick Brewster, who maintains the Windows image editor, just shipped a from-scratch rewrite of Direct2D that lives inside the application. It’s a clean-room implementation that kicks in when Paint.NET detects it’s running under WINE, the compatibility layer that lets Windows apps run on Linux and macOS. The new code ships in PaintDotNet.Windows.Direct2D1.Managed.dll.

Direct2D has been Paint.NET’s biggest compatibility hurdle for years. WINE’s implementation was never complete enough for what the app needed, and Brewster couldn’t just disable Direct2D without gutting core functionality. So instead of waiting or compromising, he rewrote it.

He credits Claude for making it possible. “This would NOT have been possible and would’ve taken me at least a few years to complete on my own,” Brewster wrote. Which makes sense when you consider what Direct2D actually is: Microsoft’s hardware-accelerated 2D graphics API, built on top of Direct3D, with hundreds of methods across dozens of interfaces.

This isn’t the first time we’ve seen AI models help with reverse-engineering work, but it might be one of the more ambitious production examples. Writing a compatible implementation of a complex graphics API requires understanding both the original behavior and the underlying graphics pipeline. Get the details wrong and nothing renders correctly.

The timing is interesting. Anthropic just released Claude Fable 5.1, which the company says “sets a new standard for coding, knowledge work, and long-running problem-solving tasks.” The new model scored 52.6% on Terminal-Bench-Science 0.1, a new benchmark announced last week. That’s up from 24.7% for Fable 5, and better than GPT-5.6 Sol’s 22.4%.

Terminal-Bench-Science measures something closer to real research work than traditional coding benchmarks. It tests whether models can handle extended problem-solving sessions with iterative debugging and complex domain knowledge. The kind of work that looks a lot like reverse-engineering a graphics API.

Other benchmarks show smaller improvements for Fable 5.1, which suggests the model got meaningfully better at sustained technical work rather than just getting slightly better across the board.

What else ships with your AI apps

In other reverse-engineering news, the ChatGPT desktop app (originally called Codex) bundles more than you might expect. Digging through ~/.cache/codex-runtimes/codex-primary-runtime/ reveals a complete Python installation, a full Node.js runtime, and native binaries for Poppler, git, and the entire LibreOffice suite.

That’s 1.7GB of software quietly living in your cache folder. LibreOffice alone is a substantial open-source office suite that forked from OpenOffice.org back in 2010. It makes sense that ChatGPT would need document handling capabilities for processing uploaded files, but shipping the whole suite is a choice.

The Python and Node runtimes explain how the desktop app can execute code from conversations. Git support means it can work with repositories directly. Poppler handles PDF rendering. It’s a self-contained runtime environment that doesn’t depend on what you have installed.

This approach solves compatibility problems but creates others. You’re maintaining multiple Python installations, multiple Node versions, and a bunch of binaries you didn’t explicitly install. Security updates become OpenAI’s problem instead of your package manager’s problem, which could be good or bad depending on how quickly they ship fixes.

Benchmarks measuring benchmarks

If you’re wondering what any of these benchmark scores actually mean, there’s new research on exactly that question. BenchMIRT from researchers at Allen AI looks at what LLM benchmarks are really measuring and whether the methodology holds up.

The meta-question matters because we’re making decisions based on these numbers. Companies are optimizing models for benchmark performance. Developers are choosing tools based on leaderboard rankings. If the benchmarks measure the wrong things, or measure the right things poorly, everyone’s optimizing for the wrong target.

The details matter here. A benchmark that tests coding ability by checking if models can solve LeetCode problems measures something different than one that tests sustained debugging work on a real codebase. Both are “coding benchmarks” but they’re not measuring the same capability.

Paint.NET’s Direct2D rewrite is a useful reminder that real engineering work often looks different than benchmark tasks. It’s iterative, requires deep domain knowledge, and success means “it actually works” rather than “it passed the test suite.” The fact that an AI model could help with this kind of work suggests the capabilities are getting closer to what developers actually need.