Jupyter is the default notebook for scientific Python — and if your work depends on the Python ecosystem, it's hard to beat. But for pure numerical computing — matrices, signal processing, plotting, exploratory math — the Jupyter route means installing Python, managing environments, and picking between NumPy, SciPy, and friends before you compute anything. Equana asks a different question: what if the notebook, the language, and the numerical kernels were one thing that opens in a browser tab? No install, no environment, all execution on your device. Equana is in alpha; here's a look at where each tool wins.

In short: need pandas, scikit-learn, PyTorch, or any of Python's hundred thousand packages? Use Jupyter. Need to open a tab and do serious numerical math with plots and a debugger, with nothing installed and nothing uploaded? That's what Equana is for.

Zero setup, batteries included

A Jupyter session starts long before the first cell: install Python, create an environment, pip install the stack, launch the server — and repeat some of it on every new machine, or hand a classroom of students the same obstacle course. Equana's environment is the URL. The interpreter, 282 numerical functions across 20 packages, and interactive plotting all load into the browser tab, and there are no imports to remember for core math — arrays, linear algebra, FFTs, and statistics are built into the language:

function r = deg2rad(x) { r = x * pi / 180 } name = "Alice" greeting = "hello ${name}" # string interpolation

Local execution, even in the browser

"Runs in the browser" usually means "runs on someone's server" — Colab and most hosted Jupyter services execute your code remotely. Equana's browser story is the opposite: the interpreter and its BLAS/LAPACK-style kernels are compiled to WebAssembly and run on your device, on a single shared linear memory, with zero server calls during execution. Your data never leaves your machine, and performance holds up: on a Ryzen 9950X, a 1000×1000 double-precision matrix multiply takes about 649 ms in plain JavaScript, about 57 ms with WASM SIMD, and about 15 ms with multithreaded WASM — around 410 GFLOPS at 4000×4000 on 32 threads. Memory is deterministic too — reference counting instead of GC means arrays are freed the moment they go out of scope, which keeps big-matrix sessions predictable.

x = 42 arr = [3, 1, 4, 1, 5, 9] f = x -> x^2 r = 1:2:10 # ranges

A real debugger in a notebook

Debugging in Jupyter is famously awkward: kernel-level debuggers exist, but most people fall back to sprinkling print() calls. Equana's interpreter is a TypeScript AST-walker running in a web worker — an architecture chosen precisely because it makes breakpoints and stepping trivial. The result is a debugger that works the way notebooks should: set a breakpoint in any cell, step line by line, and inspect every variable — scalars, arrays, matrices — mid-execution. And because the language has an optional natural-language layer, the code you step through stays readable:

let x be 42 # 'let' cosmetic, 'be'/'equals' alias '=' let square be x mapsto x^2 # 'mapsto' aliases '->' println sqrt(16.0) # bracket-free calls, chain right-to-left: sin cos 0.0

The flip side, stated plainly: Equana is alpha, its 282 functions are a fraction of what PyPI offers, and it will not run your Python code. If your workflow lives in pandas or PyTorch, stay in Jupyter.

Try it

No environment, no installs, no kernel to babysit — and no account needed to start: the examples execute code right in your browser without signing up. When you want full notebooks with storage, plots, and the debugger, sign in free and your first cell runs seconds later.