Guppy V1 Release
Major Version Release
Guppy v1.0 is the first major release of the Guppy quantum programming language. For the full list of improvements and changes, please see the changelog and the fully updated documentation website.
This release focuses on two areas: making the language more expressive and making the compiler more capable. Highlights include first-class control and dagger modifiers, protocol classes for generic programming, integrated TKET optimization, and significant compiler performance improvements.
Guppy v1.0 also introduces a small number of backward-incompatible changes as we establish a stable foundation for future releases. For most users, migrating from the 0.21.x series requires only a handful of targeted updates. A migration guide, refreshed documentation, and updated examples are available to support the transition.
A More Expressive Language
First-class control and dagger modifiers Control and dagger modifiers are now built directly into the language, making it easier to express common quantum programming patterns without thinking about how high-level operations are decomposed to gates. By elevating these operations to first-class language constructs, Guppy programs more closely reflect the underlying algorithms while remaining concise and readable. For developers implementing larger algorithms, this means clearer code and easier composition of reusable quantum operations.
See more documentation: https://docs.quantinuum.com/guppy/language_guide/modifiers/control.html
Improved type system
The type system has also been refined with native function types, replacing the use of Python's typing.Callable where appropriate. Together with protocol classes, these changes provide a more consistent programming model and improve the compiler's ability to reason about generic code. The result is stronger type checking, clearer APIs, and a more consistent developer experience when building generic quantum software.
Protocol classes
Guppy v1.0 introduces protocol classes, bringing structural typing to the language. Algorithms can now be written in terms of the capabilities a type provides rather than concrete implementations, making it easier to build reusable libraries and generic abstractions while retaining static type checking. Protocol classes make it possible to write more modular, reusable libraries without coupling algorithms to specific types, reducing duplication as projects grow.
See more documentation: https://docs.quantinuum.com/guppy/language_guide/protocols.html
A more explicit measurement model
Measurements are now represented explicitly by a dedicated Measurement type rather than immediately producing a Boolean value. This improves the language's semantics, makes measurement handling more explicit. This is now a copyable type that you can pass around your program which will block program execution until the value is available.
For existing programs, migration typically involves replacing calls such as: measure(q) with: measure(q).read(). Although this is a small API change, it removes ambiguity between quantum measurements and classical values, making programs easier to understand and enabling future language features.
See more documentation: https://docs.quantinuum.com/guppy/language_guide/measurement.html
A More Capable Compiler
Integrated TKET optimization Guppy can now optimize programs using TKET as part of the compilation pipeline. This enables circuit optimization during compilation, reducing circuit depth and gate count. Optimized circuits can translate directly into lower execution costs and improved performance on quantum hardware, without requiring changes to existing workflows.
See more documentation: https://docs.quantinuum.com/guppy/api/optimizer.html
Compiler performance
Compiler performance has been a major focus throughout the v1.0 development cycle. Numerous improvements across parsing, type checking, and compilation reduce compile times and improve scalability, particularly for larger programs. Faster compilation shortens the edit–compile–run cycle, improving productivity during algorithm development and experimentation.
Standard Library Improvements
The standard library has been refined to improve consistency and usability.Collection types such as Stack, Queue, and Priority. Queue now expose cleaner interfaces with better encapsulation, while a number of APIs have been renamed and simplified for greater consistency across the language. These refinements reduce friction when writing Guppy code and provide a more consistent API surface across the language and standard library.
Updating to Guppy v1.0
As the first major release, Guppy v1.0 includes a small number of backward-incompatible changes. For most projects, migration should involve only a small number of targeted updates rather than extensive rewrites.
The most common updates include:
- adopting the new Measurement API;
- replacing typing.Callable with Guppy Function types where required;
- updating renamed standard library APIs; and
- upgrading to Python 3.12 or later.
To support the transition, we've published:
- a comprehensive migration guide;
- a new Examples Gallery written for Guppy v1.0;
- refreshed documentation; and
- updated notebooks in the Quantinuum Nexus web portal.
Guppy v1.0 is launching today for Helios and Selene, and we will be adding limited support for System Model H2 shortly. The 0.21.x release will be supported for three months until end of October 2026.
Looking Ahead
Guppy v1.0 establishes the foundation for future language development while delivering immediate improvements in expressiveness, compiler performance, and developer productivity. We're excited to see what you'll build with Guppy v1.0.
For more information or questions on changes to Quantinuum's compute platform, please contact support@quantinuum.com.