Blaise: Object Pascal compiler targets QBE, sheds legacy baggage

This review examines Blaise, a new Object Pascal compiler project, focusing on its claims of modern design, self-hosting architecture, and QBE intermediate representation target.

TL;DR Best for: Object Pascal developers seeking a modern, unencumbered language implementation; compiler engineers interested in QBE-based backends. Skip if: You require a production-ready Object Pascal toolchain today; your project relies on legacy Delphi or Free Pascal compatibility. Bottom line: Blaise is an early-stage, technically ambitious Object Pascal compiler that prioritizes modern design and performance potential over backward compatibility.

METHODOLOGY

This v0 review draws on the founder's published claims and technical details available in the Blaise GitHub repository. Independent benchmarks and hands-on testing are pending. Our update cadence for this tool will involve re-testing when claims diverge from observed behavior or significant new features are released.

• Tool Name: Blaise
• Version: Early development (no specific version tag observed beyond commit history)
• Date Observed: 2026-05-08
• Source Signal URL: https://github.com/graemeg/blaise
• What's Covered: This review covers the technical architecture as described by the founder, the stated goals of the project (zero-legacy, self-hosting, QBE target), and the proposed language features based on the public repository's documentation and code structure. We analyze the implications of these design choices.
• What's NOT Covered: This review does not include independent performance benchmarks (compile-time or runtime), long-term workflow integration assessments, or an exhaustive analysis of all potential edge cases. We have not evaluated the project's community support or its stability in a production environment.

WHAT IT DOES

Blaise is a new compiler for the Object Pascal language, designed from the ground up to address perceived limitations of existing implementations like Delphi and Free Pascal. Its core value proposition revolves around a set of foundational architectural and language design choices.

Zero-legacy language design

The project explicitly states a goal to be a "zero-legacy" Object Pascal compiler. This means it intentionally breaks compatibility with older dialects and features that are considered historical baggage, such as goto statements, with blocks, and specific pointer arithmetic behaviors. The aim is to create a cleaner, more modern Object Pascal that aligns with contemporary programming language design principles, shedding decades of accumulated cruft for improved safety and clarity.

Self-hosting architecture

Blaise is designed to be a self-hosting compiler, meaning it is written in Object Pascal and can compile its own source code. This is a significant technical milestone for any compiler project, demonstrating the language's expressiveness and the compiler's stability early in its development. A self-hosting compiler often implies a robust parser, semantic analyzer, and code generation pipeline.

QBE intermediate target

Instead of directly generating machine code or relying on a traditional backend like LLVM, Blaise targets QBE (Quick Backend for Compilers). QBE is a lightweight, simple, and efficient intermediate representation (IR) designed for fast compilation and good code quality. This choice suggests a focus on compiler speed and maintainability, potentially allowing for easier experimentation with optimizations and cross-platform targets without the complexity of larger IR frameworks.

Modern language features

The project aims to incorporate modern language features that are common in other contemporary languages but might be missing or inconsistently implemented in older Object Pascal dialects. These include robust modules for better code organization, generics for type-safe reusable code, and closures for more flexible functional programming patterns. The zero-legacy approach facilitates the clean integration of these features without needing to reconcile them with older, conflicting paradigms.

WHAT'S INTERESTING / WHAT'S NOT

Blaise's most interesting aspect is its principled stance on legacy. By explicitly rejecting backward compatibility, the project can build a cleaner, more consistent language and compiler. This is a bold move in a language ecosystem often constrained by decades of historical baggage. For developers frustrated by the compromises inherent in maintaining compatibility with older Delphi versions, Blaise offers a genuinely fresh start.

The choice of QBE as an intermediate representation is also technically sound. QBE is known for its simplicity and efficiency, making it an attractive target for new compilers. It provides a solid foundation for generating optimized code without the steep learning curve or large footprint of more complex IRs like LLVM. This decision indicates a focus on compiler engineering excellence and potentially faster compilation times, though this remains to be benchmarked.

What's less interesting, or rather, what's missing, is concrete performance data. While the architectural choices suggest potential for speed, there are no published benchmarks comparing Blaise's compile-time or runtime performance against existing Object Pascal compilers. The "modern language features" touted are standard in many contemporary languages; their novelty is primarily within the specific context of Object Pascal's historical development, not a general innovation in compiler design. The project is also in a very early stage, meaning its immediate practical utility for most developers is limited to exploration and contribution rather than production use.

PRICING

Blaise is an open-source project, freely available under the MIT License. There are no commercial tiers or paid features associated with the compiler itself.

Pricing snapshot date: 2026-05-08

VERDICT

Blaise is a foundational project for the Object Pascal community, offering a technically sound, forward-looking compiler free from legacy constraints. Its value lies in its architectural choices—the zero-legacy design, self-hosting capability, and QBE target—which position it as a modern alternative for Object Pascal development. It is best suited for developers looking to explore modern Object Pascal or contribute to compiler development, rather than those seeking a production-ready tool today. For existing projects heavily reliant on Delphi or Free Pascal's extensive libraries and backward compatibility, Blaise is not a direct replacement.

WHAT WE'D TEST NEXT

Our next phase of evaluation would focus on empirical data and practical usability. We would benchmark Blaise's compile-time and generated code runtime performance against established Object Pascal compilers like Free Pascal, using a standardized suite of tests. We would also assess the completeness and stability of its claimed modern language features, such as generics and modules, through a series of complex test cases. Further investigation would include the quality of error reporting, ease of integration with common IDEs and build systems, and its cross-compilation capabilities for different target platforms.

Pull quote: “By explicitly rejecting backward compatibility, the project can build a cleaner, more consistent language and compiler.”