I built a simulator of the Czech quantum computer. Now you can try it free from home

Five days ago I sent a circuit to the real VLQ quantum computer in Ostrava for the first time. Today, I have 24 production jobs behind me, hundreds of circuits, several very precise measurements, a few useful dead ends and one uncomfortable answer: on current hardware, my original flagship experiment would not produce a breakthrough, but a confidently wrong result.

That's not failure. This is exactly the result that a good experiment should produce before spending the entire budget.

In the meantime, I built VLQ Lab, an interactive simulator of a specific Czech quantum computer. It can assemble and translate circuits, show amplitude flow, retrieve daily calibration, estimate errors and cost on the QPU, and compare the prediction to what actually came back from the machine.

You can open it directly at qlab.alphai.cz. Anyone can sign in with Google or any email address. The simulator itself runs in the browser and is free and unlimited; only the server-side Alpha Wolf guide and text-to-speech have usage limits.

Four terms are enough for non-technical readers. A qubit is not a "zero and a one at the same time", but a state that can be thought of as an arrow in space. A gate is an operation that changes state. Entanglement means that two qubits have a common description, even though each individually looks random. A shot is one execution of the circuit and one reading of the result; therefore the same circuit is repeated thousands of times.

Anyone can try VLQ Lab

The whitelist is no longer a barrier. Once signed in, everyone gets the full simulator and basic access to the guide:

Current limits are shown after sign-in. Anyone who needs broader access for teaching, research or their own experiments can contact me.

You can sign in with Google or request a one-time link for any email address.

Who pays for it? VLQ Lab is free and has no advertising. The public EuroHPC allocation covers compute time on VLQ. Alpha Industries s.r.o. pays for the simulator's development, server, domain, voice and the language model behind Alpha Wolf. No Wolf query is funded from the allocated compute time. The limits protect privately funded capacity and help share it among as many people as possible.

Why I started with a simulator, not a circuit

In the EU-26-106 project, I have been allocated 50,000+ QPU seconds through EuroHPC. I am investigating whether selecting a panel of language models can be formulated as a quadratic optimization problem and whether the hybrid quantum-classical QAOA algorithm could help.

By the end of August, I had submitted 24 jobs to the physical machine. This first series already revealed findings that fundamentally change the next plan, while using only a small part of the allocated time.

First, I needed an environment where mistakes could be made for free. A typical ideal simulator ignores exactly what matters on today's quantum devices: noise, decoherence, readout errors, chip topology and the actual circuit translation.

VLQ Lab therefore does not simulate an abstract quantum computer. It tries to model the specific 24-qubit VLQ, built by IQM and operated by IT4Innovations in Ostrava.

The chip layout: there is no qubit in the centre

Twenty-four superconducting qubits around the CR1 resonator. The color expresses the quality according to the selected daily calibration, the qubits of the current task are green, and the cross indicates a temporarily unavailable element.

VLQ operates at approximately 10 millikelvins, about one hundredth of a kelvin above absolute zero. Its architecture has a star topology. At the centre is not another qubit, but a CR1 resonator that acts as a transfer station.

When two qubits are to perform a joint operation, the state of one with a MOVE gate moves to the resonator, CZ takes place there, and the state is returned. The advantage is elegant: all qubits are equally distant in terms of connectivity. The disadvantage is no less important: there is only one resonator, so the two-qubit operations are sequential through it.

It was this feature that ultimately explained most of the differences between the first version of the simulator and the physical machine.

Circuit builder: what the machine can really do

Gates can be dragged from the palette or inserted with a click. Turquoise marks operations that VLQ supports directly; purple operations must be translated through the resonator.

The user can build a circuit like a construction kit. The simulator immediately distinguishes between what is drawn and what the hardware can physically execute. The native VLQ set is surprisingly small: PRX, RZ, CZ and MOVE. Hadamard, CNOT, SWAP and other textbook gates must be decomposed.

CNOT is one mark in the textbook. On the star, VLQ means two Hadamard gates, two MOVE paths and one CZ.

MOVE transfers the qubit state to the resonator and back. It is a specialty of the IQM star architecture and at the same time its busiest part.

Each gate's card has a description, matrix, Dirac notation and the actual cost of the translation. This is not just a textbook decoration. A circuit with twenty logic gates, when translated, can contain hundreds of physical operations and have completely different behavior than its drawing suggests.

Amplitude flow: see where the answer came from

Bell status step by step. The tracks show where the amplitude flows; dashed branches are interrupted. Below are the resulting probabilities and Bloch spheres of both qubits.

The histogram at the end will show what came out. The flow of amplitudes shows why. After the Hadamard gate, the state splits, the CNOT connects the branch 00 to 11, and the interfering paths can reinforce or cancel each other.

I think this is a better explanation of quantum computing than the popular saying that a computer "will try all possibilities at once". Just trying the options won't help. The algorithm must arrange for the amplitudes of the wrong responses to be canceled and the correct ones to be reinforced.

How much will the experiment cost?

VLQ Lab distinguishes gate time, post-processing time, minimum job price and number of shots. The schedule allows serialization of two-qubit operations via CR1.

The billing surprised me at first. It is based neither on wall-clock time nor solely on gate time. According to the IT4I documentation, an upper estimate is around 400 microseconds per shot: up to 50 microseconds for the circuit and roughly 350 microseconds of post-processing. Each submitted job also has a minimum charge of 0.9 QPU seconds.

This creates a practical threshold of 2,250 shots per job. Below it I pay the same even if I do less work, so I batch circuits together. Eight Bell-test circuits with 320 shots each fit into one job at the minimum charge. Sending them separately would be many times more expensive.

My log does not hide unsuccessful runs either. The biggest lesson was simple: transpile and validate locally through IQMFacadeBackend first, and only then submit to the QPU. Local checks catch most mistakes before they start consuming allocated time.

Four steps in which the model learned reality

1. Historical calibration has stopped predicting the present

I started with the useful JiriTomcala/FakeVLQ repository published by Jiří Tomčala from IT4I. It contains three snapshots of real calibrations from March and May and a noise-profile generator.

When I compared the May snapshot with the current measurement on 26 August, the correlation was only +0.015, with no overlap among the five best qubits. This is not a fault in the repository; it is evidence of hardware drift. Old calibrations are excellent for studying change, but not for choosing today's qubits.

The simulator therefore loads the live public VLQ calibration at startup. The public API shows the current state and can return a specific calibration by ID, but it does not provide a browsable history. A snapshot that was not stored may be hard to recover later. The three spring snapshots in FakeVLQ are therefore a valuable public record of drift. I now archive my own calibration snapshots as well.

2. The model was pessimistic on small circuits and optimistic on larger ones

At two and four qubits, the hardware was better than the simulator expected. At eight qubits, it's worse. So the model could not capture how quickly the quality drops with the width of the circuit.

3. Qubit ages according to total hours

The error was in my decoherence model. Each qubit aged only for the duration of its own gates. In reality, it waits throughout the time in which other qubits pass through the single resonator in sequence.

A typical six-qubit circuit with 24 CZ gates took 5.25 microseconds, while the first model counted only 1.18 microseconds for each qubit. After the fix, predicted retention dropped from 0.48 to 0.18, which is in the same ballpark as the measured 0.16. This is not a direct comparison: the model used a March calibration with p = 2, while the 26 August measurement used p = 1. The important result is that the correction moved the model in the right direction.

4. Mirror circuits revealed the law of error scaling

For the mirror test, I run a random circuit U followed immediately by its inverse U†. The correct result is always |0…0⟩, so it cannot be hidden behind a choice of metric.

The 1.36% value is not the error of a CZ gate alone. It estimates the complete composed logical operation on a pair of qubits: CZ 0.61% + 2× MOVE 0.38%.

Operation error is not a universal constant. As the circuit grows, a gate occupies the resonator while every other qubit continues to decohere. This is not just a property of the gate. It is a property of the whole circuit: the more qubits wait, the more expensive each two-qubit operation becomes. In my setup, adding a qubit hurt more than adding one more gate.

What went well

Bell's inequality: 9.6 sigma above the classical limit

Bell's test measures four combinations of bases loaded. Their correlation folds into a single number S with a hard classical limit of 2.

For the best pair, I measured S = 2.763 ± 0.079. This is 9.6 standard deviations above the classical limit of 2 and 97.7% of the Tsirelson quantum maximum 2√2.

The worst selected pair was S = 2.144. She also crossed the line, but considerably less. In addition to the explanation, the simulator is able to show why a fresh calibration and the choice of a specific pair still play a role.

The best qubit matched the published level

For qubit QB5, I estimated a single-qubit fidelity of 99.936%. For comparison, IQM reports 99.94% for its sister system Deneb. This is not a full independent benchmark of the entire device, but it is an encouraging check that the best part of the chip reaches the expected level. The spread across qubits, however, was roughly 9.5-fold.

The registered prediction finally came true

For the final entangled sampler, I recorded a correlation prediction of 0.284 before the run. The machine returned 0.270. The control circuit without entanglement gave −0.000 ± 0.014, so the signal was not merely a readout artefact.

The result tab shows the probability of the optimum, retention, distance from the ideal distribution and the number of shots. The numbers from the simulation and from the machine are always marked separately.

What didn't work and why it's more useful

The original flag experiment was to launch a panel of twelve candidates: 66 bonds and, after translation, 132 CZ gates. The estimated cost was around 400 QPU seconds.

Before running it, I performed an inexpensive depth scan. With 132 gates, the correlation with the correct solution was r = −0.75, or 26 sigma below zero. The circuit did not return random noise; it systematically preferred the wrong solutions.

That is why I did not submit the original experiment. For a fraction of its planned runtime, I learned that current hardware is beyond the useful range at this depth.

The second cold shower was methodological. Small coalition instances have five to six qubits, or at most 63 non-empty subsets. An exact classical solver can test them in microseconds. On 50 disputed questions from the held-out set, where every configuration returned an answer, the coalition formulation was better three times and worse none. The result is not statistically conclusive (p = 0.125). It did not change a single answer in the purely local panel.

This does not mean that quantum optimization is pointless. It means that first the very formulation of the problem must succeed against simple classics. A quantum computer cannot save a badly asked question.

Alpha Wolf teaches, but does not invent physics

In the School, each task has a goal, a limited palette of gates and an automatic check. Alpha Wolf advises at the start, upon resolution, or upon request.

Alpha Wolf guides users through the School tab. Rather than a blank canvas, the user receives a concrete task, a limited gate set and automatic result checking. This creates a path from the first qubit rotation to entanglement and interference.

The core teaching messages are written and verified in advance rather than generated by a language model at runtime. In quantum mechanics, accuracy matters more than infinite variety, and the guide should give everyone consistent physics. An optional Ask the Wolf feature uses AI; the daily limits apply specifically to that function.

Basics without shortcuts, which then have to be unlearned

Each chapter ends with a link to a function where the described phenomenon can be tested directly.

In Basics, I deliberately avoid writing that a qubit is simply zero and one at the same time, or that a quantum computer blindly tries every possibility. Such analogies are appealing but quickly become inadequate. I connect the explanation to the circuit builder, Bell test and amplitude flow so that every claim has an observable consequence.

Fifty-five sources, 53 with a verified link

The first group of resources covers VLQ: access and accounting documentation, calibration API, qaas client, FakeVLQ and first projects on the machine.

As of 30 August, the application contains 55 sources in eight groups. I manually opened and verified links for 53 of them. Two recommended books, by Michio Kaku and David Deutsch, do not include links:

• 9 sources directly to VLQ,
• 5 articles on star architecture,
• 7 freely available Czech and Slovak materials,
• 4 places where you can try quantum computing,
• 11 resources on the intersection of AI and quantum computing,
• 10 catalogs of algorithms and applications,
• 3 texts about the possibilities and limits of NISQ devices,
• 6 recommended books.

For each link, I explain why it is included and what its limitations are. A search engine can create a list of links; the useful part is critical reading.

Much of the credit for my reaching the machine at all belongs to the Czech team's open tools: Quantum as a Service from IT4Innovations, the aforementioned FakeVLQ, VLQ documentation and the public calibration API. They make quantum as a service practical rather than a marketing metaphor.

AI and quantum computing lead in two directions

On the left are attempts to use quantum computing for machine learning, on the right AI methods to help design, calibrate and repair quantum machines.

Quantum for AI is a louder direction: quantum kernels, variational classifiers or quantum neural networks. For classical data, he encounters the expensive recording of entry into the quantum state and the noise of today's devices.

AI for quantum machines is less flashy but has more solid results. Neural decoders help with error correction, reinforcement learning searches for better circuits, and models learn the noise of a particular device. My calibration of the simulator against measured runs also follows this direction.

The map connects eight fields with specific algorithms and draws attention to the boundaries of current demonstrations. For example, the D-Wave annealer is not the same as a gate VLQ.

Simulator in motion

The flow of the amplitudes, rotation of the Bloch sphere and running with real noise is best seen in the video:

Open video directly on YouTube

Where I am today

I have completed 24 production jobs. I measured Bell's inequality 9.6 sigma above the classical limit, corrected the decoherence-time model and stopped an experiment that would have been expensive and worthless. I also verified that some questions can be solved exactly by classical methods before quantum hardware is needed at all.

Therefore, the most valuable result is not a single number. It's a habit of writing down the prediction before the run, saving even failed jobs, and fixing the model instead of the story after every discrepancy.

If quantum computing appeals to you, start at qlab.alphai.cz with the Basics tab, then build a circuit in the Circuit Builder and finally watch Amplitude Flow. You don't have to install Qiskit or stand by the cryostat in Ostrava. All you need is a browser and the willingness to have your own ideas challenged from time to time.

Today, quantum computers can do almost nothing of what is often written about them. But what they really do is measurable, verifiable, and downright strange. And one such machine is in Ostrava.

Links and sources

For further study, I recommend starting with the original material I used while building and testing the simulator:

VLQ and access: IT4Innovations overview, access guide, QPU accounting guide, live calibration, Quantum as a Service and FakeVLQ.

Architecture and errors: qubit-resonator star processor, quantum error detection in that architecture, probabilistic quantum error correction and circuit cutting for hybrid HPC.

Capabilities and limits: Quantum Algorithm Zoo, survey of applications and end-to-end complexity, challenges in quantum optimization and Scott Aaronson's sober view of quantum machine learning.

AI and quantum computing: AlphaQubit, circuit optimization with AlphaTensor, the power of data in quantum machine learning and whether quantum advantage is the right goal for QML.

All 55 sources, each with a short note, are available in the Sources tab of VLQ Lab.

Thanks to the people who helped

I thank Jakub Siwek for encouraging me to begin working seriously with quantum computing and for arranging my first meeting with a professor. I also thank Zuzana Lichovníková from IT4Innovations for answering my questions quickly and helping whenever I needed support with access to VLQ.

My thanks also go to EuroHPC, IT4Innovations and the entire Czech team making VLQ available as a service. Their work means that using a Czech quantum computer does not require a suitcase full of cables. It takes an approved project, an account and a well-prepared circuit.

Funding and origin of the work

Compute time on the VLQ quantum computer was allocated to my EU-26-106 project through EuroHPC. The work uses support from the Ministry of Education, Youth and Sports of the Czech Republic through e-INFRA CZ (ID: 90254). This support concerns computing infrastructure and machine time on VLQ and LUMI, not the development or operation of the application.

Alpha Industries s.r.o. funds VLQ Lab, its operation, domain, Alpha Wolf guide and text-to-speech. The application is free, has no advertising and sells nothing. I created it because there is little Czech-language material on quantum computing and I wanted anyone to be able to try it without installing anything.

The simulator and experimental analyses are my own work. Calibration data comes from the public IT4Innovations API.