What is Kanad

A research commons for quantum chemistry exploration — the workshop where algorithms get built, tested, broken, shared, fixed, and evolved by the researchers themselves, together.

Kanad is a browser-based platform for quantum chemistry. Pick a molecule, select or build a quantum algorithm, run it on real quantum hardware, and get a full analysis — spectroscopy, thermochemistry, reaction pathways, molecular dynamics — without writing a single line of code.

But what makes Kanad different: every solver a researcher builds, every workflow they create, every error they discover — it gets shared. The platform gets smarter with every user. We are not building one algorithm. We are building the research commons for quantum chemistry.

In the NISQ era, no single team will solve quantum chemistry alone. The breakthroughs will come from collective exploration. Kanad is the infrastructure for that.

Vision & Mission

We are not selling immature technology. We are building the foundation so that when quantum hardware matures, we already own the platform, the relationships, the domain knowledge, and the evolved algorithms that turn hardware capability into real scientific discoveries.

Phase 1 — Now: Deploy Kanad freely to researchers. Gather users. Evolve the platform through real usage. Learn what works, what breaks, and why. Build the research commons.

Phase 2 — As hardware scales: Introduce premium capabilities for institutions. Priority hardware access, advanced analysis, dedicated support. The core platform remains free for individual researchers.

Phase 3 — When hardware matures: Sell discoveries, not tools. Quantum-accurate drug screening for pharma. Materials property prediction for defence and manufacturing. Reaction pathway optimization for energy. The platform that explored during NISQ becomes the platform that delivers during fault-tolerant quantum.

Let IBM and Google burn billions on hardware. We build the software layer where that hardware becomes useful. When the hardware is ready, the researchers are already on Kanad.

What Makes Us Different

Others optimize one algorithm. Kanad lets researchers build custom ansatze and share them. Every user makes the platform smarter. One team's learning stays with one team. A network's learning compounds.

Others chase accuracy benchmarks on known molecules. Kanad provides the full exploration workflow — reaction pathways, molecular dynamics, spectroscopy, error analysis, report generation. Accuracy is one number. A complete research workflow is what leads to discoveries.

Others keep methods proprietary. Kanad makes science open. Researchers publish using our platform, cite our algorithms, share their solvers. Every publication that cites Kanad is validation we didn't have to produce.

Others use subspace methods that constrain quantum exploration to known structures. Kanad uses standard real quantum algorithms that let the quantum system explore naturally. Quantum as explorer, not quantum as calculator.

The Innovation: Governance Protocols

Governance Protocols: the physics of bonding dictates the quantum circuit, not the other way around.

Ionic bonds get one circuit topology. Covalent bonds get another. Metallic bonds get a third. This isn't arbitrary — it's physics-informed circuit design. The result: up to 49x fewer circuit evaluations compared to generic approaches.

This means researchers spend less time waiting and more time exploring. On NISQ hardware where every circuit evaluation costs real time and real error, 49x efficiency isn't an optimization — it's the difference between a result and noise.

The Moat

When quantum hardware matures, well-funded competitors will build their own platforms. But they will start from zero on three things that money cannot buy quickly:

For this specific moment in quantum computing history — the messy, noisy, uncertain NISQ era where exploration matters more than optimization — the commons wins.

Getting Started

Your first quantum chemistry experiment in under 5 minutes.

Your First Experiment

Step 1: Sign in. Visit kanad.xyz and enter your email. You'll receive a 6-digit OTP. New users also need an access key (request one at the summit or from your institution).

Step 2: Open the Schrödinger Lab. After login you land directly in the lab. The left panel lets you build a molecule.

Step 3: Build H₂. Click "Template" and select "H₂ (Hydrogen)". This creates a hydrogen molecule at equilibrium bond length (0.74 Å) — the simplest quantum chemistry problem with an exact known solution.

Step 4: Configure the solver. Keep the defaults: PhysicsVQE, Statevector backend. PhysicsVQE achieves exact FCI accuracy on H₂ in ~22 circuit evaluations.

Step 5: Run. Click "Run Experiment". The monitor shows iteration progress in real time. For H₂ on statevector, expect results in under 10 seconds.

Step 6: Read results. You'll see energy: −1.137284 Ha. Error: 0.00 mHa (exact FCI). The analysis panel shows dipole moment, HOMO-LUMO gap, and more.

Understanding the Interface

Kanad has three main labs accessible from the left navigation bar:

The Library stores your molecules, saved results, published algorithms, and campaigns. The Logs panel (bottom, always visible) shows real-time system activity.

Schrödinger Lab

Ground-state energy calculations using the Variational Quantum Eigensolver on real and simulated quantum backends.

Building a Molecule

Use the Molecule Builder on the left panel. Three ways to define a molecule:

Templates — click any preset (H₂, HeH⁺, LiH, H₂O, BeH₂, NH₃, N₂, CO). These load pre-optimized geometries with correct charges.

Atom Picker — drag atoms from the periodic table and set bond distances manually. Good for custom diatomics.

Library — load a molecule you've saved previously.

The 3D viewer updates live. For diatomics, you can drag the bond distance slider to scan geometries before running.

Configuring a Calculation

After building your molecule, configure the solver in the right panel:

Click Preview Circuit to see the actual Qiskit circuit that will run — circuit depth, CNOT count, and qubit count are shown.

Reading Results

Results show:

Energy in Hartree (Ha). For H₂ at equilibrium, expect −1.137284 Ha.

Error in milli-Hartree (mHa) relative to FCI (exact solution). Chemical accuracy = <1.6 mHa.

HF Energy — Hartree-Fock reference (upper bound). VQE improves on this.

Convergence chart shows energy at each iteration, giving you insight into how quickly the optimizer found the minimum.

Analysis Options

After a calculation completes, Kanad automatically runs the selected analyses. Tick any combination before running:

Prigogine Lab

Time-dependent and non-equilibrium quantum chemistry: molecular dynamics, reaction pathways, and laser-matter interaction.

Molecular Dynamics

The MD simulator propagates atomic positions and velocities using classical or quantum forces at each timestep.

Force methods:

Thermostats available: Berendsen (fast equilibration), Nosé-Hoover (correct NVT ensemble), Langevin (stochastic), None (NVE microcanonical).

Integrators: Velocity Verlet (recommended), Leapfrog, Verlet.

Reading the MD Monitor

The monitor shows three phases:

Energy drift <0.1 mHa over the run indicates good energy conservation (NVE) or tight thermostat coupling (NVT).

Chemical Reactions

The reaction simulator scans the potential energy surface (PES) — computing energy at each point along a reaction coordinate (bond distance).

From the PES you can read:

Equilibrium geometry — distance at minimum energy. For H₂ this is ~0.74 Å.

Dissociation energy — energy required to break the bond (energy at large distance minus minimum).

Barrier height — activation energy for reactions that have a transition state.

Rate constant — from the Eyring equation: k = (kT/h) × exp(−ΔG‡/RT) at your chosen temperature.

Photodynamics

Simulate the interaction of a molecule with a laser pulse. Configure:

The result shows state populations over time — how the molecule moves between ground and excited states during and after the pulse.

Workshop Studio

A VS Code-like Python environment for building custom quantum solvers and ansatze — then sharing them with the community.

Pre-loaded Environment

Your code runs in a sandboxed Python environment with 30+ modules already imported. You do not need to import anything.

Writing a Custom Solver

Your class must be named CustomSolver, inherit from BaseSolver, and implement solve(**kwargs) → dict.

class CustomSolver(BaseSolver):
    def __init__(self, bond_or_molecule, **kwargs):
        super().__init__(bond_or_molecule, **kwargs)

    def solve(self, **kwargs):
        # Get the qubit Hamiltonian
        n_qubits = 2 * self.hamiltonian.n_orbitals
        n_electrons = self.hamiltonian.n_electrons
        sparse_op = self.hamiltonian.to_sparse_hamiltonian(mapper='jordan_wigner')

        # Build a hardware-efficient ansatz
        n_params = 2 * n_qubits
        qc = QuantumCircuit(n_qubits)
        for i in range(n_electrons):      # Hartree-Fock initial state
            qc.x(i)
        params = [QiskitParam(f'p{i}') for i in range(n_params)]
        for i in range(n_qubits):
            qc.ry(params[i], i)
        for i in range(n_qubits):
            qc.cx(i, (i + 1) % n_qubits)  # circular entanglement
        for i in range(n_qubits):
            qc.ry(params[n_qubits + i], i)

        # VQE optimization
        evals = [0]
        def objective(x):
            evals[0] += 1
            bound = qc.assign_parameters(dict(zip(params, x)))
            sv = Statevector.from_instruction(bound)
            return sv.expectation_value(sparse_op).real

        x0 = np.random.uniform(-0.1, 0.1, n_params)
        result = minimize(objective, x0, method='COBYLA',
                         options={'maxiter': 100})
        return {
            'energy': float(result.fun),
            'converged': True,
            'iterations': evals[0],
        }

The return dict must include energy (float, Hartree), converged (bool), iterations (int). Optional extras: n_evaluations, parameters, energy_history.

Writing a Custom Ansatz

Your class must be named CustomAnsatz, inherit from BaseAnsatz, and implement build_circuit(**kwargs) → QuantumCircuit.

class CustomAnsatz(BaseAnsatz):
    def __init__(self, n_qubits, n_electrons, **kwargs):
        super().__init__(n_qubits, n_electrons)
        self.n_layers = kwargs.get('n_layers', 2)

    def build_circuit(self, **kwargs):
        circuit = KanadQuantumCircuit(self.n_qubits)
        for i in range(self.n_electrons):
            circuit.x(i)                     # HF initial state
        for layer in range(self.n_layers):
            for q in range(self.n_qubits):
                p = KanadParameter(f'ry_{layer}_{q}')
                circuit.ry(q, p)             # rotation layer
            for q in range(self.n_qubits):
                circuit.cx(q, (q + 1) % self.n_qubits)  # circular entanglement
        self.circuit = circuit
        return circuit

Benchmarking & Publishing

Click Run in the Workshop editor to benchmark your solver against the built-in test molecules:

Once you are happy with the benchmark results, click Publish. Your solver appears in the Library's Algorithms tab where other users can fork, improve, and cite it.

Quantum Backends

Kanad runs on four hardware providers. Here is how to connect each one — no quantum background required.

IBM Quantum

IBM provides free access to real superconducting quantum computers through its open plan (up to 10 minutes of compute per month).

Getting your IBM API key

1. Go to quantum.ibm.com and create a free account.

2. After logging in, click your profile icon → Account settings.

3. Under API token, click Generate new token and copy it.

4. In Kanad: go to Profile → Backend Credentials → IBM Quantum, paste the token, and click Save.

Choosing a device

IBM provides several quantum computers. Kanad defaults to whichever has the fewest queued jobs. Current recommendations:

IBM-specific settings in Kanad

Select IBM Quantum as the backend in the Schrödinger Lab. Kanad automatically uses Batch Mode (required for the open plan) and applies ZNE error mitigation (resilience level 2) for better accuracy.

BlueQubit

BlueQubit provides GPU-accelerated quantum simulation in the cloud, supporting up to 36 qubits — far more than most local simulators.

Getting your BlueQubit token

1. Go to app.bluequbit.io and sign up for a free account.

2. Navigate to API Keys in your dashboard.

3. Click Create API Key, copy the token.

4. In Kanad: go to Profile → Backend Credentials → BlueQubit, paste the token, select CPU or GPU, and click Save.

IonQ

IonQ provides trapped-ion quantum computers with all-to-all connectivity and very low gate error rates. Their free simulator supports up to 29 qubits with no queue time.

Getting your IonQ API key

1. Go to cloud.ionq.com and create a free account.

2. Navigate to API Keys → Create.

3. Copy the API key.

4. In Kanad: go to Profile → Backend Credentials → IonQ, paste the key, and click Save.

Kanad Compute (Local Backend)

Run calculations on your own machine — no cloud required, no queue, no usage limits. The Kanad Compute package turns your laptop or server into a compute node that the Kanad web app can use.

Quick setup

# Install kanad-compute
pip install kanad-compute

# Initialize (creates API key + config)
kanad-compute init

# Start the server (default port 7440)
kanad-compute start

1. After starting, run kanad-compute key to copy your API key.

2. In Kanad: go to Profile → Backend Credentials → Kanad Compute.

3. Paste the API key and set the URL to http://localhost:7440.

4. Click Test Connection — you should see your machine's specs confirmed.

5. Select Kanad Compute as the backend in any lab. Your calculations now run locally.

Theoretical Background

You do not need to know this to use Kanad. But if you want to understand what is happening under the hood, this is the concise version.

The VQE Algorithm

VQE (Variational Quantum Eigensolver) finds the ground state energy of a molecule by using a quantum computer to measure energy and a classical computer to optimize parameters.

The four steps:

1. Prepare a state — build a parametrized quantum circuit (the ansatz) and initialize it in the Hartree-Fock state (electrons filling lowest orbitals).

2. Measure energy — run the circuit on the quantum backend and compute the expectation value ⟨ψ(θ)|H|ψ(θ)⟩. This is the energy for current parameters θ.

3. Optimize classically — use a classical optimizer (COBYLA, SLSQP) to update θ and reduce the energy.

4. Repeat — until convergence. The variational principle guarantees the result is always an upper bound to the true ground state energy.

Hamiltonians

The molecular Hamiltonian describes all energy contributions in a molecule:

H = T_e + V_ne + V_ee + V_nn

Where:
  T_e   = kinetic energy of electrons
  V_ne  = nuclear-electron attraction (negative, stabilizing)
  V_ee  = electron-electron repulsion (positive, destabilizing)
  V_nn  = nuclear-nuclear repulsion (constant for fixed geometry)

In second quantization (the form quantum computers use), this becomes:

H = Σ h_ij a†_i a_j + ½ Σ g_ijkl a†_i a†_j a_l a_k + E_nn

Where:
  a†_i / a_i = creation / annihilation operators for orbital i
  h_ij       = one-electron integrals (kinetic + nuclear attraction)
  g_ijkl     = two-electron integrals (electron-electron repulsion)
  E_nn       = nuclear repulsion constant

Kanad computes these integrals using PySCF, then converts the fermionic operators to qubit operators for the quantum computer.

Fermionic-to-Qubit Mappings

Quantum computers work with qubits, not electrons. A mapping transforms fermionic operators (electrons in orbitals) into Pauli operators (qubit gates).

Jordan-Wigner maps orbital j to a chain of Z operators: a†_j → (X_j − iY_j)/2 ⊗ Z_0...Z_{j-1}. This is exact but creates long Pauli strings.

Bravyi-Kitaev uses a tree-like parity encoding to achieve logarithmic Pauli weight — better for larger molecules.

Governance Protocols

Kanad's key innovation: the type of chemical bond determines the quantum circuit structure. This is not a heuristic — it is physics.

BondFactory automatically detects bond type from atomic electronegativities and selects the correct governance protocol. You never need to configure this manually.

Solvers Reference

Four solvers for different accuracy-speed-hardware trade-offs.

PhysicsVQE — Recommended

Uses MP2 perturbation theory to identify the most important electron excitations, then builds a minimal ansatz using only those. Result: chemical accuracy in far fewer circuit evaluations than generic VQE.

from pyscf import gto
from kanad.solvers import PhysicsVQE

mol = gto.M(atom='H 0 0 0; H 0 0 0.74', basis='sto-3g')
solver = PhysicsVQE(pyscf_mol=mol, max_excitations=5)
result = solver.solve()
print(f"Energy: {result.energy:.6f} Ha")   # -1.137284 Ha
print(f"Evals: {result.n_evaluations}")    # 22

VQESolver — General Purpose

The standard VQE with governance-aware ansatze. Good for research and exploration. Bond-based high-level API.

from kanad import BondFactory
from kanad.solvers import VQESolver

bond = BondFactory.create_bond('H', 'H', distance=0.74)
solver = VQESolver(bond, ansatz_type='governance', mapper_type='jordan_wigner')
result = solver.solve()
print(f"Energy: {result['energy']:.6f} Ha")

HardwareVQE — For Real Quantum Computers

Shallow hardware-efficient ansatz (HEA) optimized for NISQ devices. Uses circular entanglement to minimize CNOT count (8 CNOTs for H₂ vs 38 for deep circuits).

from kanad import BondFactory
from kanad.solvers import HardwareVQE

bond = BondFactory.create_bond('H', 'H', distance=0.74)
solver = HardwareVQE(bond=bond, circuit_type='hea')  # 8 CNOTs
result_local = solver.solve_local()   # Validate locally first

SQD — Subspace Quantum Diagonalization

Hybrid classical-quantum method. Uses quantum sampling to identify important Slater determinants, then diagonalizes the Hamiltonian classically in that subspace. Near-FCI accuracy for larger molecules.

from kanad import BondFactory
from kanad.solvers import SQDSolver

bond = BondFactory.create_bond('Li', 'H', distance=1.6)
solver = SQDSolver(bond, n_samples=1000)
result = solver.solve()
print(f"Energy: {result['energy']:.6f} Ha")  # -7.882 Ha for LiH

Analysis Modules

After a VQE calculation, Kanad runs scientific analyses using the converged wavefunction.

Spectroscopy

Thermochemistry

All thermochemistry is computed at 298.15 K and 1 atm by default. These correct the electronic energy to real experimental conditions.

Drug Discovery (ADME)

For drug-like molecules, Kanad computes ADME properties via ADMECalculator:

Kanad Compute Guide

Turn your machine into a quantum chemistry compute node. Run calculations locally with no cloud queue and no usage limits.

Installation

# From PyPI (recommended)
pip install kanad-compute

# From source (latest)
git clone https://github.com/mk0dz/kanad-compute.git
cd kanad-compute
pip install -e .

# With GPU acceleration (requires CUDA, Python 3.11/3.12)
pip install -e ".[gpu]"

# With IBM Quantum hardware support
pip install -e ".[ibm]"

# With IonQ support
pip install -e ".[ionq]"

# Everything
pip install -e ".[all]"

CLI Commands

# Initialize with custom settings
kanad-compute init --port 7440 --max-qubits 20 --gpu

# Start server accessible from network (for remote access)
kanad-compute start --host 0.0.0.0 --port 7440

# Configure IBM Quantum credentials on the compute node
kanad-compute configure --ibm-token YOUR_IBM_TOKEN

Configuration

Config is stored at ~/.kanad-compute/config.json:

{
  "node_id": "unique-uuid",
  "api_key": "your-api-key",
  "port": 7440,
  "max_qubits": 20,
  "max_workers": 2,
  "gpu_enabled": false,
  "ibm_api_token": null,
  "ionq_api_key": null
}

API Endpoints

The compute server exposes a REST API. All endpoints except /health require Bearer token authentication.

Kanad handles all API communication automatically. You only need to configure the server URL and API key in Profile → Backend Credentials.

Terms of Service

Last updated: April 2026

1. Acceptance of Terms

By accessing and using the Kanad Quantum Lab platform (“Service”), you agree to be bound by these Terms of Service. If you do not agree, do not use the Service.

2. Account and Access

You must register with a valid email address and an access key. You are responsible for maintaining the security of your account credentials. One account per person. Sharing access keys or accounts is prohibited.

3. Acceptable Use

The Service is provided for legitimate scientific research, education, and experimentation. You agree not to:

• Submit malicious code through the Workshop sandbox
• Attempt to overwhelm compute resources with excessively large calculations
• Use the Service for any unlawful purpose
• Reverse engineer, scrape, or redistribute platform content without permission
• Share or resell quantum backend credentials

4. Intellectual Property

You retain ownership of your experimental data, custom solvers, and research results. Kanad retains rights to the platform software, UI design, and framework code. Custom algorithms published to the community library are shared under a permissive license allowing others to fork and modify them.

5. Quantum Hardware Usage

Quantum hardware access (IBM Quantum, IonQ, BlueQubit) is subject to the respective provider's terms and usage limits. Kanad is not responsible for job failures, queue times, or costs on third-party quantum backends. Free-tier statevector simulations are limited to 16 qubits to protect server stability.

6. Limitation of Liability

The Service is provided “as is” without warranty. Kanad is not liable for data loss, calculation errors, or service interruptions. Scientific results should be independently verified before publication.

7. Termination

We may suspend or terminate accounts that violate these terms. You may delete your account at any time by contacting support. Upon termination, your data will be deleted within 30 days.

Privacy Policy

Last updated: April 2026

1. Information We Collect

Account data: Email address, name, institution, researcher type, and optional profile links (GitHub, ORCID, LinkedIn, etc.).

Usage data: Experiments run, molecules created, reports generated. Used for platform analytics and your experiment history.

Backend credentials: Quantum backend API keys (IBM, BlueQubit, IonQ) are stored encrypted and used solely to execute your experiments on the respective platforms.

2. How We Use Your Data

• Authenticate your account via OTP email verification
• Execute quantum calculations on your behalf
• Display your experiment history and reports
• Show your public researcher profile (if opted in)
• Generate platform usage statistics for administrators

3. Data Sharing

We do not sell or share your personal data with third parties. Your quantum backend credentials are transmitted directly to the respective providers (IBM, BlueQubit, IonQ) solely for job execution. Published community algorithms are publicly visible by design.

4. Data Storage and Security

Data is stored in Google Cloud SQL (PostgreSQL) with encryption at rest. Backend API keys are stored server-side and never exposed to the frontend. JWT tokens expire after 24 hours. All API traffic uses HTTPS.

5. Your Rights

You can view, edit, or delete your profile data at any time via the Profile page. You can request full data export or account deletion by submitting a feedback ticket. You control which profile fields are publicly visible via the visibility toggles in Profile settings.

6. Cookies and Local Storage

Kanad uses browser localStorage for authentication tokens, theme preferences, and solver defaults. No third-party tracking cookies are used. No analytics trackers are embedded.

7. Contact

For privacy questions or data requests, submit a feedback ticket via Profile → Feedback, or email the platform administrator.

Demo, don't pitch. The product is your credential. Open the laptop. The rest follows.

— MK, Founder, DeepRealm Labs · deeprealm.in