A year of simplifying quantum software development tools with QiskitQiskitQuantum Software

It wasn't too long ago that all quantum computers were small, experimental devices primarily used for the study of quantum computing itself. That time has passed. Today, researchers and developers all around the world-even those with minimal quantum expertise-are using utility-scale quantum hardware to explore problems beyond the limits of classical computation. The barrier to entry for running interesting experiments on quantum computers has never been lower, and more are joining the hunt for quantum advantage every day.

How did this come to be? Well, it turns out that you don't need a PhD in quantum computing to make valuable, groundbreaking advances with quantum computers. You just need the right tools. IBM delivered that on the hardware side in 2021 with the first 100+ qubit IBM Quantum Eagle processor, and we demonstrated that progress two years later with the 2023 quantum utility experiment. In 2024, we shifted more of our attention to the software side. We spent all year working hard to make Qiskit into not only the industry's most performant quantum software stack, but also its most accessible and easy-to-use.

The Qiskit software stack (2025)

Let's take a look back at some of the simplified developer tools we released in 2024 as part of that effort. Below, we recap some of our biggest quantum software releases, and provide code examples showing you how to get started using these tools to simplify your workflows.

Qiskit SDK v1.0: A more stable release cycle and consolidated features

The year 2024 brought the release of the Qiskit SDK's first major version, which introduced several new features and performance enhancements aimed at making Qiskit more versatile and powerful than ever. However, we didn't just set out to increase the Qiskit SDK's capabilities, we also set out to improve the user experience. In the Qiskit SDK v1.x era, this has manifested in a few different ways.

A stable API: Back in the days of Qiskit SDK v0.x, each new SDK release introduced breaking changes that often forced developers and project maintainers to choose between either keeping Qiskit up-to-date, or keeping their projects working. With Qiskit SDK v1.0, we've now adopted the Semantic Versioning 2.0.0 design scheme, and we've committed ourselves to providing much longer support cycles. This means that if you began using Qiskit SDK v1.0 on the first day of its release, you don't have to worry about any breaking changes until 18 months later-roughly 3-6 months after the release of Qiskit 2.0. Find more details on the new release cycle in our documentation, here.

Consolidated features: Qiskit SDK v1.0 consolidates Qiskit's core features by removing the metapackage architecture and splitting out many of our modules into completely separate packages. This work has allowed us to spend much more of our time working to enhance the stability and maintainability of the most essential parts of Qiskit, while simultaneously inviting our peers in the open-source community to contribute interesting new features.

V2 primitives: Our estimator and sampler primitives play an essential role in helping developers interact with quantum hardware through Qiskit, and we gave both of those tools a substantial overhaul with the introduction of Qiskit v1.0. The new V2 primitives are designed to accept vectorized inputs, allowing you to easily sweep over parameter value sets and observables-a capability that makes it significantly easier to collect the results of various combinations of circuits, expectation values, and parameters. Let's take a look at a quick example of the new workflows this enables:

Generic fake backend module: The Qiskit SDK v1.0 release introduces a new class within the module that allows you to easily configure and build custom instances that you can run locally. This generic fake backend gives you the ability to customize the number of qubits, the coupling map, basis gates, instruction calibrations, the ability to run dynamic circuits (a.k.a. control flow operations), and even the measurement timestep without needing to manually construct a Target object. Here's a quick example of the feature in action:

Qiskit addons: Modular tools for quantum algorithm discovery at the utility scale

Last year also saw the release of Qiskit addons -open-source, modular tools that allow researchers to easily insert the latest quantum computing techniques into their workflows while still maintaining granular control over their experiments. IBM currently offers five Qiskit addons for you to experiment with, including:

• The multiproduct formulas (MPF) addon, which aims to reduce the Trotter error of time evolution circuits.
• The approximate quantum compilation (AQC-Tensor) addon, which uses tensor networks to classically approximate as much of a time evolution circuit as possible before using quantum methods to push beyond the limits of classical tensor networks.
• The operator backpropagation (OBP) addon that helps you reduce circuit depths by essentially slicing operations off the end of your circuit, and absorbing them into the observable you've set out to measure.
• The circuit cutting addon, which reduces the depth of transpiled circuits by decomposing entangling gates between non-adjacent qubits.
• The sample-based quantum diagonalization (SQD) addon, an exciting technique with numerous potential applications that takes noisy samples from a quantum computer and produces accurate energy estimates using classical distributed algorithms.

Let's look at how easy it is to integrate Qiskit addons with your experiments. Below, we see a simplified example of a typical quantum workflow, where you start with some function that provides your circuit(s), transpile the circuit(s), and then execute and error mitigate with primitives:

We can take the same workflow and apply the operator backpropagation addon to it with just a few lines of code inserted beneath the optimize step. Here's what that looks like:

In the example above, the first line of code inserted under the optimize step ("") shows the function that takes the circuit we want to run and breaks it up into smaller pieces that can be back propagated one at a time. After that, you can specify parameters to limit the quantum and classical overhead of performing the backpropagation, so you can manage the number of experiments you'll need to do at the end and the overall classical cost.

Then, we have the main OBP method itself, which takes these parameters, performs the backpropagation, and returns whatever's left within your budget. We also see the functions that combine those results together so you can pass them forward to Qiskit primitives as a standard circuit and observable.

As you can see, the addon interfaces are easy to integrate with existing tools, but also provide a great deal of flexibility so you can adjust them for your specific problem. Learn more about Qiskit addons in our documentation, and in the individual Github repositories for the MPF, AQC-Tensor, OBP, circuit cutting, and SQD addons.

Qiskit Functions Catalog & function templates: Pre-built workflows for interacting with quantum hardware

Until very recently, doing just about anything with a quantum computer required considerable expertise in the construction of quantum circuits and in performance management for quantum hardware-high barriers to entry even if you already have some quantum experience. That changed with the recent launch of the preview release of the Qiskit Functions Catalog, a collection of programming services that give developers the ability to abstract away some of the most complex elements of the quantum software development workflow.

All Qiskit Functions fall into one of two categories:

• Circuit functions provide a simplified interface for running quantum circuits. They take your abstract circuits and observables as input and manage all the details of syntheses, optimization, and execution on quantum hardware, as well as the error handling and other post-processing required to obtain usable results. For quantum computational scientists, this means circuit functions allow you to focus on what you do best-mapping interesting problems to quantum circuits-rather than spending all your time worrying about the details of getting your circuits to run on quantum hardware.

Let's take a look at some example code using the QESEM error suppression & mitigation function built by our partners at Qedma. The QESEM function can help you generate accurate results for large circuit volumes using a combination of various quantum error handling techniques:

• Application functions handle even more of the traditional quantum software development workflow. You enter a classical input from your problem of interest, and the application function handles the rest: mapping the problem to quantum circuits, running the circuits on quantum hardware, and returning error-mitigated results. For applications researchers who may have invaluable domain expertise but minimal background in quantum computation, these tools make it easier than ever to start exploring the potential for quantum advantage in your domain.

Let's take a look at some example code using the Optimization Solver function built by our partners at Q-CTRL, which allows users to explore optimization problems with popular tools like and :

You can also build your own custom Qiskit Functions with function templates, a new tool that simplifies the process of translating individual quantum workflows into reusable application services. You don't need function templates to build your own Qiskit Functions, but they can make things a lot easier. They can do things like help you pick out relevant domain level inputs for your use case, support quantum-classical resource management, and more.

The Qiskit Functions Catalog would not exist today if not for the years of hard work we've poured into the Qiskit Serverless service, our programming model for leveraging quantum and classical resources in the cloud. Qiskit Serverless makes it easier to leverage elastic classical resources across quantum workloads. Developers can use it to flexibly define CPU, GPU, and QPU resources needed for workloads, and deploy those workloads into the cloud for remote execution. This simple concept is immensely valuable for performing complex, long-running tasks, and for handling workflows that are intended to be run on a regular basis.

In the past year, we've made numerous improvements to the Qiskit Serverless interface to make it much more approachable for new users, extended available compute and storage for your workloads, and improved the overall experience to deploy and run workloads remotely over the cloud. We've also completely overhauled our Qiskit Serverless documentation to give users a detailed guide for installing, getting started with, and deploying the Qiskit Serverless programming model.

Learn more about Qiskit Functions on the IBM Quantum blog. For additional details on Qiskit Functions and function templates, be sure to check the documentation here (Qiskit Functions) and here (function templates). For more details on Qiskit Serverless, check out our previous post on the IBM Quantum blog and the revamped documentation here.

Qiskit Transpiler Service: Cloud resources and AI-powered methods for efficient circuit transpilation

One of our most popular 2024 software releases takes the form of the Qiskit Transpiler Service preview release, which ranks among the top five most widely adopted full-stack development platforms, compilers, and simulators in the Unitary Fund's 2024 Quantum Open Source Survey. The Qiskit Transpiler Service is a powerful tool that provides quantum circuit transpilation capabilities in the cloud.

Among the most obvious benefits of the Qiskit Transpiler Service is the simple fact that performing quantum circuit transpilation in your local environment can be highly resource intensive. The transpiler service outsources that work to classical servers in IBM Cloud, freeing up your local environment for other tasks.

However, much of the excitement around the Qiskit Transpiler Service has centered on its AI-powered transpiler passes, which you can use as building blocks in your transpiling routines. By combining AI-based transpiler passes with traditional heuristic methods, you can potentially generate much more efficient quantum circuits with significantly fewer two-qubit gates than circuits generated using heuristic methods alone. Let's look at a quick example of how you can use the Qiskit Transpiler Service over the cloud with AI-powered transpiler passes:

In this example, we create a circuit and call the transpiler service to transpile that circuit with as our . Our is set to 3, and we make use of AI by setting the parameter to . AI-powered methods often result in more efficient circuit transpilation, but efficiency gains aren't guaranteed. So, if we prefer to stick with traditional heuristic methods, we'll just switch the parameter to or we'll use to get the best result possible either using any AI or heuristic method available in the service.

Find more details on the Qiskit Transpiler Service in our documentation here.

Qiskit Code Assistant: Revolutionary AI-powered quantum source code generator

The Qiskit Transpiler Service preview release isn't the only tool we delivered last year that shows how classical AI can help simplify and enhance your quantum workflows. Another promising example of this is Qiskit Code Assistant, a generative AI assistant that helps you quickly produce high-quality Qiskit code.

Qiskit Code Assistant integrates with popular development environments like Visual Studio Code and JupyterLab, and is capable of performing a variety of tasks that make it much easier to write-and learn to write-Qiskit code.

You can use the code assistant to simplify your development process, to optimize your programs to generate better quantum circuits, and to finish your projects more quickly. For example, you might ask the assistant to generate Qiskit code in response to natural language prompts or function definitions. All you need to do is type a pound () sign and tell the assistant what you want:

Alternatively, you can input your own rough code and ask the assistant to clean it up with its autocomplete functionality. Here's an example of what that looks like:

Learn more about Qiskit Code Assistant on the IBM Quantum blog here, and read the documentation here.

Get started with Qiskit developer tools today

These are just a few examples of the many ways that IBM made quantum software development easier and more accessible in 2024. Others include innovations like our new fractional gates, which can help to reduce circuit depth for utility-scale workloads, and Qiskit Runtime execution modes, which can make running utility-scale workloads significantly more efficient.

Visit IBM Quantum Platform to learn more about everything IBM has to offer, and stay tuned for the new innovations in quantum software development coming in 2025!

Public link

Please use the above public link if you want to share this noodl on another website.