Visual circuit builder
Place gates on qubit wires and watch the Python and QASM update live. Run without writing a line of code.
Quantum cloud · early access
The quantum cloud
The quantum cloud
for everyone who builds.
Design a circuit, run it on real quantum simulation, and read an honest result — from your browser or your code. No queue rituals. No gatekeeping. Just build, run, and learn.
100 free credits · no credit card · real results
ψ = (|0⟩+|1⟩)/√2
live · roro.sim.sv
# pip install roro-quantum from roro import RoRoClient from qiskit import QuantumCircuit qc = QuantumCircuit(2, 2) qc.h(0) qc.cx(0, 1) qc.measure([0, 1], [0, 1]) roro = RoRoClient(api_key="qcs_live_…") job = roro.submit_run("roro.sim.sv", shots=5000, circuit=qc, wait=True) print(job["counts"]) # → {'00': 2503, '11': 2497}
sampling · 0 shots
0
% real execution — simulators & quantum hardware
0
qubits in the visual builder
0
gate types, one click each
0
free credits to start
The mentality
Quantum computing has spent a decade behind queues, enterprise calls, and jargon. We think it belongs to anyone with a question and the curiosity to run it. So we built one place to build, run, and understand — honest results, no theatre.
— RoRo Quantum
Why RoRo
Quantum, without the gatekeeping.
Most quantum access still assumes a PhD, an enterprise contract, and a tolerance for queues. We took all of that out.
The old way
- Enterprise sales calls before you can run anything
- Long hardware queues with no feedback
- SDK setup, credentials, and provider lock-in
- Jargon-heavy docs written for physicists
- Opaque, surprising bills
With RoRo Quantum
- Build and run in your browser in under a minute
- Real results — instant on simulators, queued on real QPUs
- One SDK, one API key — providers abstracted away
- Lessons that teach by doing, not by lecturing
- Transparent credits — 100 free to start, no card
The platform
Everything you need to run quantum.
Design, run, and analyze — then bring your team and your students along.
Real execution
Simulator targets run on real simulators (Qiskit Aer locally, partner-grade in the cloud); QPU targets queue and execute on real superconducting hardware. Honest counts, never a mockup.
Credits, made simple
Transparent per-shot pricing, like tokens. Buy credits, allocate budgets, and track every run.
Teams & organizations
Owners, admins, members. Invite by email, assign workspaces, and set budgets. Stay in control.
Lessons & certificates
Learn by doing — theory, an interactive lab, and a quiz per lesson, all the way to a certificate.
Python & Kotlin SDKs
Write standard Qiskit, authenticate with an API key, and submit & track runs straight from your code.
How it works
From idea to result in three steps.
01
Build
Drag gates in the builder, pick a template, or write a QuantumCircuit in code.
02
Run
Choose a target and shots. We execute it on real Qiskit simulation and debit credits.
03
Read
Get normalized counts, probabilities, entropy, and the most likely outcome — ready to plot.
Examples
Real circuits, real results.
The same code you'd write in Qiskit — run it, and read what comes back.
qc = QuantumCircuit(2, 2) qc.h(0) qc.cx(0, 1) # entangle qc.measure([0, 1], [0, 1]) job = roro.submit_run("roro.sim.sv", shots=4000, circuit=qc, wait=True)
counts
Two qubits, perfectly entangled — you only ever see 00 or 11.
qc = QuantumCircuit(3, 3) qc.h(0) qc.cx(0, 1) qc.cx(1, 2) qc.measure([0, 1, 2], [0, 1, 2]) job = roro.submit_run("roro.sim.sv", shots=4000, circuit=qc, wait=True)
counts
Three-qubit entanglement — all-zero or all-one, nothing in between.
qc = QuantumCircuit(1, 1) qc.h(0) # equal superposition qc.measure(0, 0) job = roro.submit_run("roro.sim.sv", shots=8000, circuit=qc, wait=True)
counts
One Hadamard, a fair coin — about half 0, half 1.
qc = QuantumCircuit(2, 2) qc.h([0, 1]) qc.cz(0, 1) # oracle marks |11> qc.h([0, 1]) qc.measure([0, 1], [0, 1]) job = roro.submit_run("roro.sim.sv", shots=4000, circuit=qc, wait=True)
counts
One Grover iteration amplifies the marked state — the answer is 11.
The math, briefly
It's linear algebra you can run.
A qubit is a vector, a gate is a matrix, and a measurement is a probability. Here's the whole idea in four lines.
Superposition
$$H\,|0\rangle = \tfrac{1}{\sqrt{2}}\big(|0\rangle + |1\rangle\big)$$
A Hadamard gate puts a qubit into an equal blend of 0 and 1 — a fair quantum coin.
A gate is a matrix
$$H = \tfrac{1}{\sqrt{2}}\begin{pmatrix}1 & 1\\[2pt] 1 & -1\end{pmatrix}$$
Every gate is a unitary matrix acting on the qubit's state vector.
Entanglement
$$|\Phi^{+}\rangle = \tfrac{1}{\sqrt{2}}\big(|00\rangle + |11\rangle\big)$$
The Bell state: two qubits whose measurement outcomes are perfectly correlated.
Measurement · Born rule
$$P(x) = \big|\langle x\,|\,\psi\rangle\big|^{2}$$
The probability of each outcome is the squared amplitude — exactly what your shots estimate.
Learn
Learn quantum by doing.
A full course lives inside the console — units, interactive labs, exams and challenges. Each lesson pairs clear theory with a circuit you build and run yourself. Free with your account.
Qubits & superposition
Your first gate — the Hadamard — and the |+⟩ state, built and measured.
The Bell state
Entangle two qubits with H + CX and verify perfect correlation.
GHZ & beyond
Scale entanglement, then on to algorithms — Deutsch–Jozsa, Grover, teleportation.
Visual builder
Build circuits by clicking.
Pick a gate, click a wire, and it appears — qubits, controls, rotations, measurements. The Python and QASM 2.0 update as you go, so the visual and the code are never out of sync.
One- and two-qubit gates, rotations, measurement
Bell, GHZ, superposition, and Grover templates
Run and see the outcome distribution instantly
q0
H
q1
XH
q2
ZM
For developers
If you know Qiskit,
you already know RoRo.
Build circuits the standard way, point the client at your API key, and run them through RoRo. Results come back normalized and ready to plot — in Python or Kotlin.
Standard QuantumCircuit in, normalized counts out
Submit, track, and fetch runs from code
One API key, the same call everywhere
from roro import RoRoClient from qiskit import QuantumCircuit qc = QuantumCircuit(2, 2) qc.h(0); qc.cx(0, 1) qc.measure([0, 1], [0, 1]) roro = RoRoClient(api_key="qcs_live_…") job = roro.submit_run("roro.sim.sv", shots=5000, circuit=qc, wait=True) print(job["status"]) # completed print(job["counts"]) # {'00': 2472, '11': 2528}
Learn
From your first qubit
to your first algorithm.
Every lesson pairs short theory with an interactive lab and a quiz. Run real circuits as you learn, and earn a certificate when you finish the track.
Theory → lab → quiz, lesson by lesson
Built for classrooms — workspaces and budgets per student
A shareable certificate at the end
01
Qubits & superposition
Your first Hadamard and a fair quantum coin.
02
Entanglement
Build a Bell state and a GHZ state, and measure them.
03
Your first algorithm
Run Grover's search and read the amplified answer.
Who it's for
Built for the curious and the serious.
Companies
Prototype, experiment, and manage spend across teams — one clean interface instead of stitching SDKs together.
Schools & universities
Give every student a workspace and a credit budget. Built-in lessons, labs, and certificates make a full curriculum.
Enthusiasts
Free credits to start. Build, run, and learn at your own pace — from your first Bell state to Grover's search.
Pricing
Public pricing. No sales call.
Credits work like tokens: each run costs a small amount per shot, debited from your balance. These are the real numbers.
1,000 credits
$10
$0.0100 / credit
5,000 credits
$47.50
$0.0095 / credit
Best for classes
25,000 credits
$200
$0.0080 / credit
100,000 credits
$750
$0.0075 / credit
Every new account starts with 100 free credits — no credit card required.
Per-shot rates
| Machine | Credits / shot | 5,000-shot run |
|---|---|---|
| RoRo Sim | 0.005 | 25 cr |
| RoRo Noisy Sim | 0.025 | 125 cr |
| RoRo Simulator Pro | 0.05 | 250 cr |
| RoRo Tester | 0.05 | 250 cr |
| RoRo Quantum G1 / G2 / G3 / A1 | 0.25 | 1,250 cr |
cost = shots × per-shot rate — a 5,000-shot run on RoRo Sim is 5,000 × 0.005 = 25 credits, exactly what the run record shows. The live catalog in the console is always authoritative.
A classroom, priced end-to-end
- One lab run — 1,000 shots on RoRo Sim 1,000 × 0.005 = 5 cr
- One student — 4 runs a week 4 × 5 = 20 cr
- One semester — 15 weeks 15 × 20 = 300 cr
- The whole class — 50 students 50 × 300 = 15,000 cr
- Three 5,000-credit packages 3 × $47.50 = $142.50
A full semester of weekly quantum labs for a 50-student class: $142.50 — under $3 per student. Each student's own 100 free credits add another 5,000 credits of headroom on top.
FAQ
Questions, answered.
Do I need to know how to code?
No. The visual builder lets you place gates and run circuits without writing a line. If you do know Qiskit, the Python SDK and REST API feel completely native.
Are the results real?
Yes. Simulator targets run on real simulators — Qiskit Aer on our instant local tier, partner-grade simulators in the cloud — and QPU targets queue and execute on real superconducting quantum hardware. You get honest counts and probabilities, never a canned animation.
What does it cost?
You start with 100 free credits, no card required. After that the numbers are public: a shot on RoRo Sim costs 0.005 credits, so a 5,000-shot run is 25 credits. Credit packages start at 1,000 credits for $10 and go down to $0.0075 per credit at 100,000. The full per-shot table and a worked classroom example are in Pricing.
Can I use this with my class or team?
Absolutely. Create an organization, invite members by email, give each a workspace and a credit budget, and track every run. Built-in lessons make it a full curriculum.
Which languages can I use?
Python and Kotlin SDKs today, plus a language-agnostic REST API. Write a standard QuantumCircuit, authenticate with an API key, and submit runs from anywhere.
How safe are my API keys?
Keys are shown once at creation, stored only as hashes, scoped to your organization, and revocable at any time from the console.
Run your first circuit
in under a minute.
100 free credits. No credit card. One login away.