Beryllium applies familiar object-oriented programming principles to quantum software development. It allows developers to define reusable quantum data types analogous to those used in today’s classical programming languages, enabling Triple Alpha users to build complex quantum programs by reusing and extending previously defined components. Using simple classical and quantum building blocks, programmers can progressively create richer, higher-level structures.

Object-oriented programming (OOP) is a programming paradigm that organizes software design around objects that contain attributes (data) and behavior (code).

Programmers define classes, which act as blueprints for objects and specify the attributes and behavior common to all objects of a class. An object is an instance of a class—a concrete entity that holds its own data, while sharing the structure and behavior the class defines.  

Because each object bundles together its data and the code that operates on it, developers can build programs from many interacting objects without needing to understand how each one works internally. They can also reuse previously defined classes or draw from libraries, reducing duplication and speeding up development. 

OOP provides abstraction and modularity, managing complexity by breaking programs into smaller, self-contained units. This approach makes software easier to maintain, extend, and debug while reducing the need to rewrite functionality from scratch.

Many of OOP’s advantages could also translate to quantum programming. However, the OOP paradigm is fundamentally built for a world where data behaves classically, which creates challenges when applying the programming framework to quantum systems. 

In classical programming, OOP works because developers can treat data as persistent objects with a well-defined state. This classical model relies on assumptions that the user can duplicate or manipulate data, inspect it without changing it, and encapsulate data to control its state.

Quantum computing, by its very nature, breaks those assumptions. The laws of quantum physics prevent users from copying quantum data (the no-cloning theorem) and from inspecting (measuring) it without changing it. As a result, OOP for quantum computing cannot be a direct translation of classical OOP because its foundation—objects with a persistent, inspectable state—clashes with quantum physics. Quantum programmers cannot freely copy an object or inspect it without disturbing its quantum state, nor can they assume it holds a concrete value before measurement.

Given this tension, most quantum programming frameworks do not rely heavily on object-oriented concepts. Instead, they either incorporate OOP design lightly—primarily for structuring code in Python-based software development kits (SDKs)—or avoid it in favor of other paradigms, such as function-first or declarative models.

Addressing this mismatch requires rethinking the OOP model from first principles, rather than extending what already exists. This "rethinking" needs to balance three competing demands: correctness, so that the programming model respects quantum mechanics; familiarity, so classical programmers can use it; and abstraction, so developers are not forced to think in terms of circuits.

Most existing programming frameworks prioritize one demand at the expense of the others. Many prioritize familiarity by exposing quantum concepts through Python SDKs. In these, developers can use classical OOP constructs to wrap a quantum description. However, because Python is a classical language, it cannot enforce core quantum constraints at the language level. As a result, correctness is managed through libraries and conventions, and developers are still implicitly working at the circuit level.

Other frameworks move in the opposite direction, adopting function-first or domain-specific approaches. These prioritize mathematical rigor or closer adherence to hardware constraints but require developers to think more like mathematicians or physicists than software engineers.

Declarative approaches take a different path: developers specify what a program should achieve, and the system constructs the underlying circuit as a “black box,” prioritizing abstraction over control and visibility.

Often, these quantum programming frameworks remain anchored to the circuit-level paradigm—even when presented through higher-level abstractions or wrapped in more user-friendly tools.

Beryllium represents a fundamentally different approach to quantum programming. Rather than functioning as a Python SDK or providing wrappers for circuit construction, it is a purpose-built programming language designed to move away from circuit-level thinking and enable truly expressive quantum programming—where developers can write code that directly expresses what a program should achieve, rather than how the underlying circuits should be constructed.

Beryllium sits within Horizon Quantum’s broader Triple Alpha development infrastructure. Built with a powerful compiler and Turing-complete languages, Triple Alpha compiles code written in Horizon’s higher-level languages down to its lower-level languages and ultimately for execution on target quantum computers.

As the highest language level available in Triple Alpha, Beryllium sits on top of Helium—Horizon’s BASIC-like language—and above Hydrogen—Horizon's assembly-like language.

By eliminating the need to think in circuits, Beryllium allows developers to write quantum programs in a way that more closely resembles classical software engineering. They can describe problems in structured, familiar terms while delegating low-level implementation details to Triple Alpha’s compiler.

A purpose-built quantum programming language, Beryllium seeks to bridge the gap between classical and quantum programming. Developers can work with classical data types as they would in languages such as C or C++, alongside quantum data types within the same program. Classes can contain both classical and quantum objects, and the entire program can be compiled to run on a hybrid system supporting interacting classical and quantum computation, with the quantum components executed on a quantum processing unit (QPU) and the classical components evaluated by Horizon’s execution infrastructure. Because Beryllium combines classical and quantum data structures within a recognizable development environment, Triple Alpha users can work with familiar control flow structures while using quantum datatypes.

Beryllium makes quantum software development more accessible to those without deep quantum expertise. At this level, developers don’t need to be hardware experts.

By operating at this higher level of abstraction, Beryllium enables developers to focus on program logic and produce hardware-agnostic quantum programs with advanced features such as control flow, functions, and classes and objects that contain a mix of classical and quantum data types.

Additionally, as an object-oriented language, Beryllium allows developers without expertise in quantum algorithms to begin building quantum-accelerated applications by using modules written by others.

Taken together, Beryllium’s advanced capabilities represent a shift in how quantum software can be written and understood. By supporting familiar control flow structures, modular design, and reusable components, Beryllium allows developers to construct quantum programs in a way that mirrors modern classical software engineering. As a result, quantum programs become easier to read, work with, and scale.

As quantum computing moves toward broader adoption, it will require a much larger pool of developers who are not specialists in quantum hardware. Providing familiar programming constructs lowers the barrier to entry and makes it possible for classical programmers to contribute meaningfully to quantum applications. By bringing quantum development closer to established software practices, Beryllium is working towards laying the foundation for a future in which quantum computing can be integrated into mainstream development workflows.