QuantSDK — Write Quantum Code Once, Run Anywhere

A framework-agnostic quantum computing SDK by TheQuantAI

Documentation | Getting Started | API Reference | Examples | Discord

What is QuantSDK?

QuantSDK is a framework-agnostic quantum computing SDK that lets you write quantum circuits once and run them on any backend — IBM Quantum, IonQ, GPU simulators, and more.

No more vendor lock-in. No more rewriting circuits for each framework. One API, every quantum computer.

Features

• Framework-Agnostic — Write once, export to Qiskit or OpenQASM 2.0
• QuantRouter — Rule-based smart routing picks the best backend for your circuit
• Cloud Client — Connect to TheQuantCloud for remote execution and job management
• Pythonic API — Clean fluent interface, minimal boilerplate
• 50+ Gates — 44 gate classes, 54 named entries including all standard, parametric, and multi-qubit gates
• Rich Results — Histograms, probabilities, DataFrames, expectation values
• Interop — Seamless import/export with Qiskit circuits and OpenQASM 2.0
• Fast Simulator — Pure NumPy statevector simulator, up to 24 qubits
• Well Tested — 330+ tests across 10 test modules
• Open Source — Apache 2.0 license

Installation

pip install thequantsdk

With optional backends:

pip install thequantsdk[ibm]     # IBM Quantum + Aer support
pip install thequantsdk[gpu]     # GPU simulator support
pip install thequantsdk[interop] # Qiskit interop
pip install thequantsdk[viz]     # Matplotlib visualization
pip install thequantsdk[all]     # Everything

Quick Start

import quantsdk as qs

# Create a Bell State circuit
circuit = qs.Circuit(2, name="bell_state")
circuit.h(0).cx(0, 1).measure_all()

# Run on local simulator (default)
result = qs.run(circuit, shots=1000, seed=42)

print(result.counts)         # {'00': 503, '11': 497}
print(result.probabilities)  # {'00': 0.503, '11': 0.497}
print(result.most_likely)    # '00'

Run on Real Quantum Hardware

# Run on IBM Quantum
result = qs.run(circuit, backend="ibm_brisbane", shots=1000)

# Run on Aer simulator
result = qs.run(circuit, backend="aer", shots=1000)

# Smart routing — let QuantRouter pick the best backend
result = qs.run(circuit,
    optimize_for="quality",
    max_cost_usd=0.50,
    shots=1000)

Framework Interop

# Export to Qiskit
qiskit_circuit = circuit.to_qiskit()

# Import from Qiskit
qs_circuit = qs.Circuit.from_qiskit(qiskit_circuit)

# Export to OpenQASM 2.0
qasm_str = circuit.to_openqasm()

# Import from OpenQASM
qs_circuit = qs.Circuit.from_openqasm(qasm_str)

Rich Results

result = qs.run(circuit, shots=4000, seed=42)

result.counts              # Raw counts dict
result.probabilities       # Normalized probabilities
result.most_likely         # Most frequent bitstring
result.top_k(3)            # Top 3 outcomes
result.summary()           # Pretty-printed summary
result.expectation_value(0)  # <Z> on qubit 0
result.to_pandas()         # pandas DataFrame
result.plot_histogram()    # Matplotlib histogram
result.to_dict()           # Full serializable dict

Gate Library

QuantSDK includes 44 gate classes with 54 named entries in the gate map:

Circuit Inspection

circuit = qs.Circuit(3, name="ghz")
circuit.h(0).cx(0, 1).cx(1, 2).measure_all()

circuit.num_qubits       # 3
circuit.depth             # 3
circuit.gate_count        # 6  (H + 2 CX + 3 Measure)
circuit.count_ops()       # {'H': 1, 'CX': 2, 'Measure': 3}
circuit.draw()            # ASCII circuit diagram
circuit.copy()            # Deep copy
circuit.reset_circuit()   # Clear all gates

Examples

The examples/ directory contains 22 Jupyter notebooks organized by difficulty:

Beginner (01-07)

Intermediate (08-14)

Advanced (15-18)

Interop & Backends (19-22)

Architecture

src/quantsdk/
  __init__.py              # Public API: Circuit, Result, run
  circuit.py               # Circuit class with fluent gate API
  gates.py                 # 44 gate classes, 54 GATE_MAP entries
  result.py                # Result with counts, probabilities, viz
  runner.py                # qs.run() multi-backend routing
  backend.py               # Abstract Backend interface
  router.py                # QuantRouter — rule-based smart backend routing
  cloud/
    __init__.py            # CloudClient — TheQuantCloud API client
    config.py              # Cloud configuration and endpoint management
  simulators/
    local.py               # Pure NumPy statevector simulator
  interop/
    qiskit_interop.py      # Qiskit <-> QuantSDK conversion
    openqasm.py            # OpenQASM 2.0 <-> QuantSDK conversion
  backends/
    ibm.py                 # IBM Quantum + Aer backend adapters

Documentation

Full documentation is available at docs.thequantcloud.com:

• Getting Started — Installation, first circuit, core concepts
• API Reference — Circuit, Result, Gates, Runner, Backend
• Tutorials — Bell states, Grover's, VQE, teleportation
• Backend Guides — IBM Quantum, Aer, local simulator
• Contributing — How to contribute

Contributing

We welcome contributions! Please see CONTRIBUTING.md for:

• Development setup instructions
• Code style and testing guidelines
• How to add new gates and backends
• Commit message conventions

License

Apache 2.0 — see LICENSE for details.

Security

To report security vulnerabilities, please see SECURITY.md.

About TheQuantAI

QuantSDK is built by TheQuantAI — building the infrastructure layer for quantum computing.

• TheQuantCloud (thequantcloud.com) — Quantum Computing Cloud Platform
• TheQuantDefense (thequantdefense.com) — Quantum Solutions for Defense & Aerospace