Demo chip (KQC)

KQCircuits’ demonstration chip: four flux-tunable Swissmon qubits in a ring, read out through two probe lines, each with its own charge line and flux line. It is the standard KQC example, rebuilt on the Quantcore PDK (sapphire, Quantcore die frame, Quantcore trilayer junctions).

Build it to see a complete multi-qubit chip made from KQC components: ARD24 launchers, readout capacitors and T’s, meandered resonators, ring couplers and control lines.

The whole demo chip as the notebook builds it

At a glance

Notebook

examples/designs/kqc/demo.ipynb (an older one-cell version is kept as demo.v1.ipynb)

Source

KQCircuits chips/demo.py (Demo), © IQM Finland Oy, GPL-3.0

Chip

10 × 10 mm, ARD24 sample-holder launchers

On the chip

4 Swissmons · 4 λ/2 readouts (5000 to 5300 µm) · 2 probe lines · 4 ring couplers · 4 charge and 4 flux lines · 2 junction-test arrays

Builds today

yes (layout built on 2026-11-19 in 12 s)

How the notebook builds it

The eight layout segments of the Demo chip, one picture each
  1. Die. The empty 10 × 10 mm chip with the Quantcore frame (dicing marks, alignment grids, chip boundary, device ID) and the ARD24 launchers.

  2. Bond pads. The launchers moved so their outer etch edge sits 100 µm from the die edge (the pad rule).

  3. Qubits. Four Swissmons at KQC’s positions with Quantcore SQUIDs.

  4. Probe lines. Readout capacitors and T’s, then the two probe lines.

  5. Readouts. Four λ/2 meandered resonators from the qubits to the capacitors.

  6. Ring. Four couplers join neighbouring qubits into a ring.

  7. Control lines. Charge and flux lines from the launchers.

  8. Whole chip. Sim groups, content centred in the die, design saved.

LOM estimates

Numbers are from a run of this notebook on 2026-11-19 (Setup, Design, Check and the LOM cells, 18 s): QuCat normal modes with QuTiP dressed values.

group

qubit

f_q (GHz)

α (MHz)

resonator

f_r (GHz)

κ (MHz)

χ (MHz)

QB1+RR1

QB1

5.81

-200

RR1

11.38

2.9

-0.115

QB2+RR2

QB2

5.81

-200

RR2

11.07

11.8

-0.118

QB3+RR3

QB3

5.81

-200

RR3

10.96

4.23

-0.121

QB4+RR4

QB4

5.81

-200

RR4

10.72

8.12

-0.125

group

pair

ZZ (kHz)

neighbours

hybridised

ring

QB1-QB2

–

yes

yes

ring

QB2-QB3

–

no

yes

ring

QB2-QB4

–

yes

yes

ring

QB1-QB3

–

yes

yes

ring

QB1-QB4

–

no

yes

ring

QB3-QB4

–

yes

yes

pair

f₋ (GHz)

f₊ (GHz)

g = Δf/2 (MHz)

QB1+QB2

6.002

6.008

2.84

QB2+QB4

6.002

6.008

2.84

QB4+QB3

6.002

6.008

2.84

QB3+QB1

6.002

6.008

2.84

LOM plot of demo

These are lumped-model estimates (component formulas and calibration), not FEM results; see the LOM page for how far to trust them.

Build spec

The rest of this page is the detailed spec the notebook was built from: every component, port, route and length.

Source other-libs/KQCircuits-main/KQCircuits-main/klayout_package/python/kqcircuits/chips/demo.py (Demo) · GPL-3.0 (IQM Finland). The notebook rebuilds the chip from extracted parameters and uses KQC cells through the registry; no KQC code is copied. What it is: 4 flux-tunable Swissmons in a ring of 4 CPW buses. Each qubit has a meandered readout resonator, coupled through a finger capacitor and a T to one of 2 probelines, plus a drive line and a flux line. There are 2 junction-test arrays. 10 × 10 mm. The KQC frame is already (0,0)–(10000,10000), so no shift is needed. Face 1t1, KQC default layers. Checked on 2026-11-02 with plan_design: every route length below equals the KQC build to 0.01 µm, and d.lom() connects everything (no unconnected ports).

Coordinates were read from a scratch build of the KQC chip, which gives the refpoints. Default chip parameters (a=10, b=6, r=100) apply unless a value is given.

Components

instance

catalog ref

key params (units)

at (x, y)

rot

notes

QB1

Swissmon

cpl_length=[120,120,120], port_width=[4,10,4]; other params default (SQUID Manhattan, FluxlineStandard)

(3220, 7000)

0, mirror=True

cplr0 W (3001,7000), cplr1 S (3220,6781), cplr2 E (3439,7000), drive (3020,7200), flux N (3220,7245.33)

QB2

Swissmon

same

(6780, 7000)

180

cplr0 E, cplr1 S (6780,6781), cplr2 W, drive (6980,7200)

QB3

Swissmon

same

(3220, 3000)

0

cplr1 N (3220,3219), drive (3020,2800), flux S (3220,2754.67)

QB4

Swissmon

same

(6780, 3000)

180, mirror=True

cplr1 N (6780,3219), drive (6980,2800)

C1–C4

FingerCapacitorSquare

finger_number 4 / 8 / 5 / 7

(4656.5,6181) / (5343.5,6181) / (4656.5,3819) / (5343.5,3819)

0 / 180 / 0 / 180

readout coupling C; port a faces the resonator

PL1–PL4

WaveguideCoplanarSplitter

lengths=[11,11,41], port_names=["right","left","bottom"]

(4734,6181) / (5266,6181) / (4734,3819) / (5266,3819)

270 / 90 / 270 / 90

snap bottom to Ck.b (gives these values; galvanic in the LOM)

CIN1

FingerCapacitorTaper

finger_number=6, taper_length=20

(4734, 8192)

270

series input capacitor of probeline 1

CIN2

FingerCapacitorTaper

finger_number=3, taper_length=20

(5266, 1808)

90

series input capacitor of probeline 2

testarray_w/e

JunctionTestPadsSimple

margin=50, area_height=2500

(900,3750) / (7800,3750)

0

no ports

Routes

route

from → to

type, length (µm)

waypoints

notes

CPL12

QB1.cplr2 → QB2.cplr2

cpw a=4 b=9, 3122.0

(3839,7000), wp(6161,7000, n_bridges=3)

bus

CPL24

QB2.cplr0 → QB4.cplr0

cpw a=4 b=9, 4714.16

(7399,7000), wp(7399,3000, n_bridges=3)

bus

CPL43

QB4.cplr2 → QB3.cplr2

cpw a=4 b=9, 3122.0

(6161,3000), wp(3839,3000, n_bridges=3)

bus

CPL31

QB3.cplr0 → QB1.cplr0

cpw a=4 b=9, 4714.16

(2601,3000), wp(2601,7000, n_bridges=3)

bus

DLk

chip.DL-QBk → QBk.drive

cpw 2478.23, term2=6 (open)

QB1 (780,8000), QB2 (9220,8000), QB3 (780,2000), QB4 (9220,2000)

diagonal straight into the directionless drive port

FLk

chip.FL-QBk → QBk.flux

cpw 2074.77

wp((QBk.x, 7345.333 or 2654.667), n_bridges=4)

20 µm jog in x, slanted

RR1

QB1.cplr1 → C1.a

meander=5000

(3220,6181), (3520,6181), (4520,6181)

meander auto-placed on (3520→4520)

RR2

QB2.cplr1 → C2.a

meander=5100

(6780,6181), (6480,6181), (5480,6181)

RR3

QB3.cplr1 → C3.a

meander=5200

(3220,3819), (3520,3819), (4520,3819)

RR4

QB4.cplr1 → C4.a

meander=5300

(6780,3819), (6480,3819), (5480,3819)

PL1_in / PL1_a / PL1_b / PL1_out

chip.PL-1-IN → CIN1.a / CIN1.b → PL1.left / PL1.right → PL2.left / chip.PL-1-OUT → PL2.right

1344.66 / 1968.5 / 1646.16 / 3376.16

[(4400,9220),(4734,9220)] / [wp(4734,7000, airbridge)] / [(4734,5570), wp(5266,5570, n_bridges=1)] / [(5600,9220),(5266,9220), wp(5266,7000, airbridge)]

airbridges where the probeline crosses CPL12

PL2_in / PL2_a / PL2_b / PL2_out

chip.PL-2-IN → CIN2.a / CIN2.b → PL4.left / PL4.right → PL3.left / chip.PL-2-OUT → PL3.right

same lengths

[(5600,780),(5266,780)] / [wp(5266,3000, airbridge)] / [(5266,4430), wp(4734,4430, n_bridges=1)] / [(4400,780),(4734,780), wp(4734,3000, airbridge)]

crosses CPL43

Verified Designer code (J: the source gives no junction values, so pick them from targets):

L = {2: "FL-QB1", 3: "PL-1-IN", 4: "PL-1-OUT", 5: "FL-QB2", 7: "DL-QB2", 12: "DL-QB4",
     14: "FL-QB4", 15: "PL-2-IN", 16: "PL-2-OUT", 17: "FL-QB3", 19: "DL-QB3", 24: "DL-QB1"}
d = Designer("kqc_demo", launchers={"type": "ARD24", "assign": L}, chip={"name_chip": "Demo"})
SW = dict(cpl_length=[120, 120, 120], port_width=[4, 10, 4]); W = Designer.waypoint
q = {1: d.add("QB1", "Swissmon", at=(3220, 7000), mirror=True, junction=J, **SW),
     2: d.add("QB2", "Swissmon", at=(6780, 7000), rot=180, junction=J, **SW),
     3: d.add("QB3", "Swissmon", at=(3220, 3000), junction=J, **SW),
     4: d.add("QB4", "Swissmon", at=(6780, 3000), rot=180, mirror=True, junction=J, **SW)}
d.route("CPL12", q[1].cplr2, q[2].cplr2, a=4, b=9, nodes=[(3839, 7000), W((6161, 7000), n_bridges=3)])  # + CPL24/43/31
for k, (x, y, rot, nf, xt, xm, Lr) in {1: (4656.5, 6181, 0, 4, 3520, 4520, 5000), 2: (5343.5, 6181, 180, 8, 6480, 5480, 5100),
                                      3: (4656.5, 3819, 0, 5, 3520, 4520, 5200), 4: (5343.5, 3819, 180, 7, 6480, 5480, 5300)}.items():
    c = d.add(f"C{k}", "FingerCapacitorSquare", at=(x, y), rot=rot, finger_number=nf)
    d.add(f"PL{k}", "WaveguideCoplanarSplitter", snap="bottom", to=c.b, lengths=[11, 11, 41], port_names=["right", "left", "bottom"])
    d.route(f"RR{k}", q[k].cplr1, c.a, meander=Lr, nodes=[(3220 if k in (1, 3) else 6780, y), (xt, y), (xm, y)])
d.route("DL1", "chip.DL-QB1", q[1].drive, nodes=[(780, 8000)], term2=6)
d.route("FL1", "chip.FL-QB1", q[1].flux, nodes=[W((3220, 7345.333), n_bridges=4)])          # + DL/FL 2..4
ci = d.add("CIN1", "FingerCapacitorTaper", at=(4734, 8192), rot=270, finger_number=6, taper_length=20)
d.route("PL1_in", "chip.PL-1-IN", ci.a, nodes=[(4400, 9220), (4734, 9220)])
d.route("PL1_a", ci.b, "PL1.left", nodes=[W((4734, 7000), airbridge=True)])               # + PL1_b, PL1_out, PL2_*

Launchers, pads, test structures, markers, labels

  • ARD24 with KQC names (only the 12 assigned pads are drawn). N: FL-QB1 #2 (3200,9320), PL-1-IN #3 (4400,9320), PL-1-OUT #4 (5600,9320), FL-QB2 #5 (6800,9320). E: DL-QB2 #7 (9320,8000), DL-QB4 #12 (9320,2000). S: FL-QB4 #14 (6800,680), PL-2-IN #15 (5600,680), PL-2-OUT #16 (4400,680), FL-QB3 #17 (3200,680). W: DL-QB3 #19 (680,2000), DL-QB1 #24 (680,8000).

  • Junction-test arrays W/E (see the table). The chip frame, markers and the “Demo” name come from the DesignChip base.

LOM node structure (qubit ↔ resonator ↔ feedline ↔ bus ↔ control lines)

  • QBk: island with C to ground and a SQUID to ground; cplr0/1/2 nodes each have C_g and C to ground (Swissmon model: Xmon-scaled estimates).

  • Bus ring QB1–QB2–QB4–QB3–QB1. Each CPL route is one conductor in the LOM (plain cpw), so for example QB1.cplr2 and QB2.cplr2 merge. In reality the buses are long (3.1/4.7 mm, about λ/2 at 13–19 GHz), so treat them as wires only as a first approximation.

  • RRk: λ/2 TLres at QBk.cplr1 (meander port↔port). Ck gives the series C to the probeline node.

  • Probeline 1: chip.PL-1-IN, CIN1, {PL1, PL2}, chip.PL-1-OUT (QB1, QB2). Probeline 2: chip.PL-2-IN, CIN2, {PL4, PL3}, chip.PL-2-OUT (QB4, QB3). Each splitter is one node, and the launchers are 50 Ω ports.

  • DLk becomes a drive control on QBk and FLk a flux_bias control on J_QBk. Lumped f(RR) ≈ 12.1–12.8 GHz (λ/2, PDK sapphire). KQC sizes the chip for silicon.

Targets (if stated)

None in the source, which is geometry only. readout_res_lengths=[5000,5100,5200,5300], include_couplers=True.

Simplifications for a first rebuild

  1. Skip testarray_w/e and the airbridge n_bridges. Keep the airbridge waypoints at the four probeline–bus crossings, which would otherwise be galvanic crossings. d.drc() on the full rebuild (tested) gives only two no_lom warnings, for the test arrays.

  2. include_couplers=False variant: drop CPL*. KQC then also drops the probeline airbridges.

  3. Quantcore-flow variant (λ/4 + κ in the LOM): drop Ck/PLk/CINk, run each probeline as one cpw route (chip.PL-1-IN → chip.PL-1-OUT via x=4734/5266), and use RRk → PL.hanger(...) on its vertical segment. Not KQC geometry.

Quantcore PDK rebuild

The notebook is a Quantcore-PDK rebuild of the source chip. The netlist, LOM and imported components are kept, and the process is Quantcore’s.

Notebook: examples/designs/kqc/demo.ipynb.

  • Chip: the Quantcore die frame (L dicing markers 1000/0, 3 × 3 alignment grids 1001/0, chip boundary 100/0, device ID where an edge is free; any brand text is QCT), drawn on the source’s 10 × 10 mm chip (its launchers sit on the chip edges, so the design does not fit the 7.5 mm die). KQC’s ChipFrame (dicing edge, corner markers, labels) is not drawn. KQC’s original grids its whole ground plane (with_grid, 5 µm squares on a 10 µm step). The rebuild keeps that coverage at the PDK density instead (chip parameter cheese: "chip", with_grid: false): 5 µm squares with 20 µm gaps over the whole die, at least 4 µm from the 3/0 keep-outs, inside the design area and clear of the frame markers and the device ID.

  • Stack: sapphire 650 µm, εr 10.25 (the PDK default stack, used by the LOM estimates and every FEM export); KQC’s own simulation default is silicon (εr 11.45), so LOM capacitances and resonator frequencies here are for sapphire.

  • Junctions: Quantcore Nb/AlOx/Nb trilayer junctions (junction_type from layouts.registry.trilayer_junction): fingers on 2/0 + 4/0, spacer 50/0 with the 51–53/0 gradient, sized on the PDK junction rule (Nb Δ = 1.4 meV, I_c·R_n = πΔ/2e, R_n·A 13.5 kΩ·µm² and C_J 50 fF/µm² assumed); every Swissmon’s SQUID becomes a PDK SQUID of two 0.25 × 0.6 µm junctions → R_n = 45 kΩ in parallel, L_J = 6.73 nH at zero flux, C_J = 15 fF (in the 40–50 kΩ window). KQC’s junction_width sets the straight finger. This replaces the assumed Lj 16 nH + 2 fF. Expected f_q ≈ 5.8 GHz (was 3.94 GHz), still below the ≈ 11–12 GHz λ/2 readouts (estimate from the pre-rebuild LOM C_Σ). The two JunctionTestPads arrays get the same Quantcore SQUID.

  • Kept: the topology and every KQC element with the source’s parameters, positions and orientations, the launcher assignment, every route’s path and length, the sim groups (readouts 5000–5300 µm, the ring couplers, the junction-test arrays).