Python in the browser

Every .py file runs in a real CPython 3.12 (Pyodide) inside a Web Worker in your tab. No server, no credits; the only network it touches is %pip fetching pure-Python packages from PyPI (and the Pyodide runtime itself).

#Running a file

Open a .py and two buttons appear: ▶ Run file in the tab strip and Run in browser in the Run rail. Output streams into the dock's output tab, prefixed by ▶ main.py. While the kernel starts (your first run, or the lab warming it up) the button reads Starting kernel… and there is nothing to stop yet. Once your program runs, the tab-strip button becomes Stop — a real KeyboardInterrupt where the browser allows it (cross-origin isolation, which lab.roroquantum.com sets), a worker restart otherwise, and the log says which one happened (or that the run was cancelled before it started). If the program ignores it, Force stop restarts the kernel (variables lost). A second run is never queued behind a running one — it would run after your Stop.

The status bar names the kernel's state, the same words the notebook toolbar and Copilot's run card use: kernel loading… (the kernel itself is still downloading) → kernel not started — Run boots it → kernel booting — Loading NumPy… → kernel ready, and kernel running / kernel stopping… while a program runs. If it says kernel unavailable, in-browser runs are off (a Chromium-based browser usually fixes it); .qasm files still submit from the Run rail.

#What "run" means, exactly

• The whole project is written into the interpreter before every run — including unsaved edits — so main.py can import ansatz, a package with __init__.py works, and open("data.csv") opens the file in the tree.
• __name__ == "__main__" and __file__ are set; sys.path starts with the file's folder, then the project root.
• Editing a module and re-running re-imports it; nothing runs stale.
• Tracebacks are trimmed to frames inside your project. Explain this error in the Output pane sends the log to Copilot (metered).

#The SDK that is already there

The kernel boots with the real roro_platform SDK wheels (roro-quantum-platform 1.0), so code written here runs on your laptop unchanged once its pending PyPI release lands (until then pip installs the deprecated REST client roro-quantum):

from roro_platform import Platform, Config, Circuit
from roro_plugin_sim_local import LocalSimulator

sim = Platform(config=Config(usage_file=None, api_key=None, default_target="local.sim.sv"),
               plugins=[LocalSimulator()])
qc = Circuit(2); qc.h(0); qc.cx(0, 1); qc.measure_all()
print(sim.run(qc, shots=1000).counts)   # {"00": ~500, "11": ~500}

Local simulation is free and offline. The wheels also carry roro_platform.qml, roro_platform.synthetic (labelled example data) and roro_platform.solve. rq.copilot refuses here; use the Copilot rail. Machines — code names at the bottom of the Run rail lists every machine with its codename — the exact string submit_run() / run() take, identical in every SDK and the API. Copy the example line there (roro.submit_run("<codename>", shots=1000, circuit=qc)) into your own environment with an API key (mint one in the Integrate rail → API keys); inside the lab, hardware submissions go through the .qasm Run rail, which quotes and confirms before holding anything — the browser kernel deliberately carries no credentials and never spends credits on your behalf.

#What it cannot do (and says so)

No qiskit, pennylane, scipy, cirq, torch, pandas — compiled packages with no WebAssembly build. import qiskit fails with one sentence naming the package, never a resolver traceback. Pure-Python packages install with %pip install <name> in a notebook cell. numpy and matplotlib are present (figures render under notebook cells). No threads, no subprocesses.

Related: Notebooks · Copilot · For teams & integration