QBE 1.3 Brings Windows Support and Faster Code Generation
QBE 1.3 Brings Windows Support and Faster Code Generation
QBE 1.3 was released today with support for Windows computers, improved speed, and better code quality. The update adds about 7,000 lines of new code while removing 1,500 lines that were no longer needed, according to the official release notes.
The most important change is that QBE can now create programs for Windows. Until now, it only worked with Linux, macOS, and some specialized systems. This makes QBE useful for people building programming tools that need to work on multiple platforms.
What Got Faster
QBE 1.3 runs about one-third faster than the previous version. It now compiles code at 63% of the speed of expensive, commercial compilers—a solid result for a tool designed to be simple and lightweight.
The speed improvements came from new techniques added by Roland Paterson-Jones and improvements in how the software matches code patterns. The goal of QBE has always been to be fast enough for practical work while being small enough that one person can understand the entire codebase.
To give a sense of scale: QBE can compile itself in two seconds on a laptop. This speed matters when you're developing software, because you spend less time waiting and more time coding.
Shared Libraries and Code Reuse
QBE 1.3 can now generate code that works in shared libraries—the reusable chunks of code that multiple programs can tap into without duplicating it. On Linux and Unix systems, this uses a standard technique called the global offset table, which is how modern software keeps code flexible and portable.
This is important for language designers who want to use QBE as their foundation. They can now build full libraries and expect them to work across different systems.
How Windows Fits In
Scott Graham added the ability to create Windows-native code by supporting the Windows x64 calling convention—essentially, the set of rules about how programs pass information to each other on Windows. This is different from how Linux and macOS work, so QBE needed separate code to handle it.
For people building programming languages or development tools that need to work everywhere, this is meaningful. They no longer need to hire separate engineers to build a Windows version or write complex translation layers.
Why QBE Stays Simple
QBE is built on a philosophy of deliberate constraint. Instead of building layers of optimization on top of each other like bigger compilers do, QBE uses one clean middle representation throughout. This trades away some performance potential in exchange for being simple enough that a single developer can hold it all in their head.
The broader context here is that we have seen this before. When LLVM arrived in the 2000s, its appeal was that it gave language designers a clean foundation to build on without writing architecture-specific code for each processor. QBE follows that same idea, but takes simplicity even further—it aims to be fast to compile and easy to understand, rather than squeeze every drop of performance from running code.
The choice to aim for 70% of commercial compiler performance is pragmatic. Most real programs spend their time waiting for disk access, memory retrieval, or working through algorithms—not in tight computational loops where compiler wizardry makes much difference. For students, prototyping, or situations where compile time matters, QBE's trade-off makes sense.
Who Is Building This
QBE development happens in the open through a mailing list and internet chat rooms. The project stays focused on a core set of features, which means individual contributors can make real architectural changes without navigating layers of bureaucracy. Graham's Windows work and Paterson-Jones's optimizations are good examples.
The balance of new code and removed code—7,000 lines added, 1,500 removed—suggests active refactoring and consolidation. This discipline keeps the codebase manageable.
With Windows support, faster compilation, and better library support, QBE 1.3 is more practical for real-world projects. If you are building a programming language or tool and want to generate native machine code without the weight of a massive compiler framework, this version makes that significantly easier.
