evergreen hero asset

Microsoft Quantum Technical Blog

Boost Your Quantum Development with AI-Assisted Coding and New Chemistry Capabilities

Microsoft Quantum Development Kit (QDK) v1.27.0 and QDK for chemistry v1.1.0

 
Authors:

Sasha Efimovskaya, Principal Program Manager

David Williams-Young, Principal Quantum Software Engineer

Stefan Wernli, Principal Quantum Software Engineer

As quantum algorithms grow more sophisticated, teams need powerful tools that support practical, scalable quantum development. With this release, Microsoft’s Quantum Development Kit takes a major step forward. QDK v1.27.0 delivers stronger insight into program behavior, richer developer tooling, and first-class program composability across Q#, Python, OpenQASM, and leading frameworks such as Qiskit and Cirq. QDK v1.27.0 improves how developers build, inspect, and assemble quantum programs, making it easier to iterate on complex algorithms using reusable components.

 

AI‑assisted quantum development is now a first‑class experience in the QDK, elevating quantum development across the entire workflow. Deep integration with Visual Studio Code and GitHub Copilot brings intelligent assistance to every stage, from code generation and circuit reasoning to debugging, visualization, hardware submission, and resource estimation. Enhanced circuit diagrams, quantum state inspection, and a streamlined VS Code experience make iteration and exploration faster, more reliable, and more interactive across Python, Jupyter, and Q#.

 

Alongside these core advances, QDK for Chemistry v1.1.0 expands what can be explored on today’s early fault‑tolerant hardware. In response to strong user demand, the release adds support for a broad family of model Hamiltonians, introduced through a systematic workflow that connects real molecular systems to reduced models such as the Fermi‑Hubbard Hamiltonian. Combined with stronger core primitives, deeper ecosystem integration, and a significantly faster classical pipeline, QDK for Chemistry enables practical chemistry and materials science experimentation today while laying the groundwork for larger‑scale quantum capabilities ahead.

 

Together, these updates advance quantum computing from basic research toward practical, hardware-aware quantum engineering.

 

Download Microsoft’s QDK and QDK for chemistry

 

QDK v1.27.0

Improved circuit rendering 

With this QDK update, branches based on measurement results are now shown in circuit diagrams as classically controlled operations, with a label indicating the measurement results that trigger the branch. This makes it easier to understand the structure of algorithms that involve mid-circuit measurement and classical control flow.

 

Diagram showing classically controlled branches driven by mid‑circuit measurements visualized inline
Classically controlled branches driven by mid‑circuit measurements are visualized inline, making conditional logic in quantum programs easier to follow and debug.

 

 

The quantum circuit editor has also been updated to include a state visualizer panel that shows the quantum state resulting from running the circuit, with live updates as the circuit is edited. It visualizes both the probability density and the phase for each basis state, allowing developers to see in real time how changes to the circuit affect the quantum state.

 

Image of circuit editor including a live quantum state visualizer showing probability amplitudes and phases in real time as the circuit is edited.
The circuit editor now includes a live quantum state visualizer (right), showing probability amplitudes and phases in real time as the circuit is edited.

 

VS Code & GitHub Copilot: Improved knowledge and streamlined experience

 

The QDK extension for VS Code works seamlessly with GitHub Copilot to help you write quantum programs in Q#, OpenQASM, and Python. Alongside code generation, Copilot in VS Code can also tap directly into QDK tooling—simulating quantum programs, generating circuit diagrams, running resource estimates, and submitting jobs to Azure Quantum—all as part of agentic workflows that preclude disruptions. 

 

With this release, we’ve expanded the QDK-specific guidance available to GitHub Copilot. The VS Code extension now includes a new qdk programming Copilot skill spanning Q#, OpenQASM, and the qsharp/qdk Python API. When working in relevant contexts, Copilot can automatically draw on this QDK knowledge with no additional setup, or developers can invoke it directly in Copilot Chat using /qdk-programming for targeted help with quantum programming tasks. 

 

The result is smarter, more context-aware assistance throughout the development experience: fewer hallucinated function names, stronger use of Q# idioms, and more reliable guidance when working with QDK Python packages. 

 

Program composability in the QDK

 

This version of the QDK extends Python interoperability to enable quantum program composability by dynamically assembling algorithms from interchangeable subroutines, even when those components originate in different languages or frameworks. 

 

Q# already treats operations and functions as first-class values—they can be passed as arguments, returned from functions, and composed into larger programs. These capabilities are now directly accessible from Python by: 

 

  • Mapping structured Python data (such as dictionaries or classes) to Q# user-defined types 
  • Allowing callables to flow across the Python-Q# boundary in both directions 

 

These capabilities allow developers to express the core algorithm structure while supplying concrete implementations, such as state preparation or Pauli evolution routines, as pluggable subcomponents. 

 

Composability also extends beyond Q#. With full support for OpenQASM, programs defined in other ecosystems can be imported as operations and used as first-class subroutines, enabling seamless composition across Q#, OpenQASM, and frameworks such as Qiskit and Cirq.

 

            
                from qdk.openqasm import import_openqasm
from qdk import qsharp

import_openqasm("""
    include "stdgates.inc";
    qubit[2] qs;
    h qs[0];
    cx qs[0], qs[1];
""", name="Entangle")

qsharp.eval("""
operation TestAntiCorrelation(entangler : Qubit[] => Unit) : Result[] {
    use qs = Qubit[2];
    X(qs[1]);
    entangler(qs);
    return MResetEachZ(qs);
}
""")

            
        
You can now import OpenQASM programs and use them as subroutines passed from Python into your quantum algorithms.

 

Program composability leveraged in application libraries

 

Building on upstream improvements to QDK composability, this release delivers first-class Q# support across core primitives of QDK for chemistry. Circuits generated by the library can be represented directly in Q#, allowing developers to take advantage of Q# as a high-level language for building reusable program components rather than depending on the circuit-composition model. 

 

In practice: 

 

  • The overall algorithm structure (for example, iterative QPE) is expressed once in Q#, enabling seamless compilation, optimization, and simulation through the QDK toolchain. 
  • State preparation, Hamiltonian evolution, and other steps are supplied as interchangeable components from any language. 
  • Those components can be written in Q#, imported from OpenQASM, or generated by external toolchains. 

 

This approach makes chemistry algorithms easier to express and evolve, while reducing complexity. It also improves compilation efficiency by allowing the QDK compiler to operate on richer program structure and reuse shared infrastructure directly. 

 

Combined with Q# circuit generation and OpenQASM and QIR conversion, this model seamlessly connects chemistry workflows to the broader quantum ecosystem. Furthermore, researchers are not tied to a single platform —for example, they can use QDK for chemistry for problem definition and resource estimation, then execute workflows on the backend that best matches their hardware access. 

 

QDK for chemistry v1.1.0

Expanding the problem space with model Hamiltonians

 

Image of the benzene molecule (left) mapped to a Hückel model Hamiltonian (right), represented as a one‑dimensional ring of six sites
The benzene molecule (left) can be mapped to a Hückel model Hamiltonian (right), represented as a one‑dimensional ring of six sites. QDK for chemistry v1.1.0 introduces this and other model Hamiltonians, enabling practical exploration of chemistry and related quantum problems.

 

 

First-principles Hamiltonians in quantum chemistry are large, complex, and unforgiving. Even a modest active space can demand thousands of terms and deep circuits that exceed the capability of current devices. Model Hamiltonians offer a practical detour: By capturing the essential physics of a system in a simplified representation, they reduce the computational burden to a level where quantum algorithms become tractable—and quantum advantage over classical methods becomes achievable. 

 

QDK for chemistry now provides comprehensive support for a broad family of model Hamiltonians across two major categories: 

 

  • Fermionic models—Hückel, Hubbard, and Pariser–Parr–Pople, covering tight-binding band structure and strongly correlated electron physics 
  • Spin models—Ising and Heisenberg, the workhorses of condensed-matter and statistical-mechanics simulation 

 

All models are defined over arbitrary lattice geometries, giving researchers the flexibility to study chains, ladders, honeycomb lattices, or any custom topology relevant to their physics. The implementation is designed for accessibility at every experience level: Early practitioners can use turn-key workflows for standard use cases, whereas advanced users have full access to low-level primitives for custom algorithm development and experimentation. 

 

Crucially, the modular architecture of QDK for chemistry means that model Hamiltonian workflows share the same component interfaces as first-principles workflows. Swapping a Hubbard model for a molecular Hamiltonian—or plugging in a new lattice geometry—requires changing only the problem specification, not the algorithm or the pipeline. This composability accelerates exploration and keeps the toolkit future-proof as quantum hardware scales. 

 

Sharper quantum primitives: robust unitary decompositions

 

Expressing a problem as a Hamiltonian is only the first step; translating that Hamiltonian into an efficient gate sequence is where algorithmic choices directly impact performance on real hardware. This release delivers significant improvements to the core quantum primitives that power that translation. 

 

Trotter–Suzuki decompositions are the most widely used method for compiling Hamiltonian time evolution into a gate sequence. The order of the decomposition controls the tradeoff between circuit depth and approximation error: Higher orders yield more accurate unitaries at the cost of additional gates. QDK for chemistry now supports Trotter decompositions of arbitrary order, giving researchers fine-grained control over this tradeoff. 

 

This is especially valuable in the context of quantum phase estimation, where the accuracy of the Trotterized time-evolution operator directly affects the quality of the energy estimate. Higher-order expansions reduce the Trotter error for a given step count, enabling shorter circuits that fit within the coherence window of near-term devices—or, equivalently, more accurate results for a fixed circuit depth. A comprehensive set of accompanying utilities allows users to benchmark different orders against their target Hamiltonian and estimate resource requirements before committing to a hardware run. 

 

A stronger classical pipeline

 

The classical pipeline—orbital optimization, localization, Hamiltonian construction, and active space selection—forms the foundation on which every quantum simulation rests. An inaccurate or inefficient classical preprocessing stage can negate the benefits of even the most sophisticated quantum algorithm. As problem sizes grow toward industrially relevant scales, the performance of these classical routines becomes a genuine bottleneck. 

 

This release introduces two major improvements. First, QDK for chemistry now supports factorized electron repulsion integrals, including those obtained via Cholesky decomposition. Factorization dramatically reduces the memory footprint and computational cost of storing and manipulating the two-electron integrals that dominate quantum chemistry calculations, making it feasible to tackle larger molecular systems. 

 

Second, the library introduces enhanced algorithms for open-shell orbital optimization, with particular focus on Restricted Open-Shell Hartree–Fock (ROHF). Accurate treatment of systems with unpaired electrons—transition-metal complexes, radicals, and excited states—is essential for many interesting quantum chemistry problems. Improved ROHF support broadens the scope of systems that QDK for chemistry can handle reliably and efficiently. 

 

Together, these classical improvements expand the practical reach of the QDK for chemistry. Problems that were previously impractical due to memory constraints or poor convergence in orbital optimization are now within scope, enabling researchers to pursue utility-driven quantum computing across near-term and future architectures. 

 

See the full feature list in our release notes: 

 

Microsoft’s QDK: What's new in QDK v1.27.0

 

QDK for chemistry: What’s new in QDK for chemistry 1.1.0

 

 

 

Download Microsoft’s QDK and QDK for chemistry

 

 

In the video below, hear directly from David and Stefan as they discuss the key updates in this release and what they unlock for practical quantum development.