Quantum Computing

Qiskit Enables Building Quantum Circuits Directly from Fortran, C++, and Julia Without Python

IBM announced that the C interface in Qiskit, built on the Rust core, enables use of the development package from Fortran, C++, and Julia without requiring a Python layer. The change targets integrating quantum circuits directly into high-performance computing and scientific simulation workflows.

2026-10-06
4 min read
347 views
certi.news Editorial Team
Qiskit Enables Building Quantum Circuits Directly from Fortran, C++, and Julia Without Python

IBM has expanded Qiskit’s entry points beyond Python by enabling its use from Fortran, C++, and Julia through a unified C interface that reaches the high-performance core written in Rust. The company says this design allows quantum circuits to be built and run directly within existing applications, without embedding a Python interpreter or transferring data into Python objects.

The move has been available since Qiskit 2.0, which introduced the C interface for the development package’s underlying data model. Because the three language bindings use the same shared Qiskit library, circuits created in one language can, in principle, be passed to another language such as C++ and Fortran while retaining the same object.

Three Paths to Qiskit

For Fortran, IBM provides the qiskit-fortran interface for building and handling circuits, using the standard iso_c_binding mechanism to call the C interface. The circuit uses a derived type that frees memory when the variable leaves scope. Data such as a Hamiltonian can also be passed directly from quantum chemistry applications already residing in Fortran memory to circuit-building procedures, without copying it into Python or reallocating it.

As for qiskit-cpp, which IBM first announced the previous year, it is a C++ interface that works through header files only. A program can be linked to the Qiskit C library, while the circuit object’s memory is managed automatically when it leaves scope. IBM mentions the possibility of sending circuits through the C client for qiskit-ibm-runtime or through QRMI and SQC.

Qiskit.jl and QiskitIBMRuntime.jl provide an interactive path for Julia users, including work inside Jupyter notebooks and access to IBM Quantum hardware. The two packages hide the details of C pointers and also enable circuits to be created and run in a style close to Qiskit in Python, while accounting for the fact that Julia starts qubit numbering at 1 whereas Python uses numbering from 0.

What Changes in Practice?

The new interfaces target researchers whose scientific applications rely on Fortran, C++, or Julia, particularly in simulation, physics, chemistry, engineering, and high-performance computing. Instead of running Qiskit as a separate process or using Python to coordinate every step, the quantum circuit can be called as a linked procedure within the classical application itself. This includes building the circuit, optimizing it for specific hardware, sending it to the hardware, and then processing the results.

IBM demonstrates this path through a Julia example simulating a transverse-field Ising model on a system of up to 100 qubits. The example includes approximating the evolution of the Schrödinger equation using Trotterization, then optimizing the circuit, running it on hardware, and calculating site magnetization. The example’s conceptual results show that reducing the Trotter step size lowers approximation error but increases circuit depth, which may ultimately produce more hardware noise than the gain resulting from increased accuracy.

Limitations and Open Questions

IBM emphasizes that all non-Python bindings are still under active development, so the announcement does not present final stable interfaces or detailed comparative performance results. The 100-qubit example also does not mean that the practical limitations of quantum computing have been overcome; the classical tensor-network simulation reference becomes less reliable as entanglement increases, while execution accuracy remains tied to Trotter error and hardware noise.

The core value here is reducing software friction in integrating quantum resources into existing HPC code, not providing new quantum capabilities in itself. The impact of the interfaces will depend on the maturity of the packages, their integration with current research environments, and the ability of quantum hardware to deliver results beyond what classical alternatives provide.

News source
IBM Quantum Blog
Open original source ↗
c
Author

certi.news Editorial Team

What you need to know

IBM has enabled Qiskit to be used from Fortran, C++, and Julia through a C interface that reaches a Rust core, allowing quantum circuits to be integrated directly into high-performance computing applications without requiring Python. These interfaces are still under development, and the announcement did not present detailed performance comparisons or final stable APIs.

  • Qiskit's C interface enables quantum circuits to be built and executed from Fortran, C++, and Julia without embedding a Python interpreter or transferring data into Python objects.
  • The new interfaces rely on the Rust-written Qiskit core, and circuit objects can be shared among the three languages through the shared Qiskit library.
  • IBM provides the qiskit-fortran and qiskit-cpp packages, as well as Qiskit.jl and QiskitIBMRuntime.jl for Julia users.
  • The move targets simulation, physics, chemistry, engineering, and high-performance computing applications that already use these languages.
  • A Julia example demonstrates simulation of an Ising model with up to 100 qubits, balancing Trotter approximation error, circuit depth, and hardware noise.
  • The non-Python interfaces remain under active development, and the 100-qubit example does not mean that practical limitations of quantum computing have been overcome.

FAQ

Which languages can be used with Qiskit without Python?

Qiskit can be used from Fortran, C++, and Julia through a unified C interface.

What is the practical benefit of these interfaces?

They allow quantum circuits to be called directly within existing scientific applications, built and optimized, sent to hardware, and processed without using Python to coordinate every step.

Are the new interfaces stable and final?

No. IBM states that the non-Python bindings are still under active development, and the announcement did not present final stable APIs.

Does the 100-qubit example represent a breakthrough in quantum capability?

No. The article explains that the example does not mean practical limitations of quantum computing have been overcome, and that the results remain tied to Trotter approximation accuracy and hardware noise.

In the same category

You may also like

View all news