Python, billed by the
millisecond.

Send code, get output. Your numeric loops are transpiled to Mojo and cached by content hash, so a kernel you call more than once runs natively — and you pay for the milliseconds your program actually ran, nothing else.

Open the editor Sign up — $1 free Read the API new accounts get $1 of compute · browser runs are free

Try it

GPU auto: decides where this belongs

output appears here

…or write the Mojo yourself no interpreter at all

Same estimate, same arithmetic, written in Mojo instead of Python. We build it here — the compile is on us and cached by content hash — and run the binary. Nothing is interpreted, so there is no first call to warm up: it is native from the first instruction. Mojo runs always go to our machines; there is no wasm build to fall back to.

billed the same way: the milliseconds your program ran

output appears here

Signed out, this runs in your own browser — free, private, unlimited. Create an account (or sign in) for our machines, GPUs, the full package index and longer runs; the first 1000 credits ($1) are on us.

The API is one endpoint

curl

curl -s https://mojojojo.app.nz/v1/run \
  -H "Authorization: Bearer $MOJOJOJO_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "code": "print(sum(i*i for i in range(10)))",
    "packages": ["numpy"],
    "timeout_ms": 10000
  }'

response

{
  "ok": true,
  "stdout": "285\n",
  "billable_ms": 41.8,
  "accel": {"compiled": 0, "native_calls": 0},
  "charge": {"billed_ms": 41.8, "credits": 0,
             "owed_ms": 41.8, "balance": 4820}
}

41.8ms does not cost a whole credit, so it does not round up to one. Milliseconds accrue against your balance and a credit moves when they cross 10000ms. Nothing is lost in either direction.

JavaScript — free when it can be

import { run } from "https://mojojojo.app.nz/mojojojo.js"

const r = await run(`print(sum(range(10)))`)
r.stdout   // "45\n"
r.where    // "browser" — ran on your machine, cost nothing

const g = await run(train, { gpu: true, apiKey: KEY })
g.where    // "server" — wasm has no GPU, so this one is billed

mojojojo.js runs your Python in the caller's own browser via WebAssembly and only reaches for our machines when the browser genuinely cannot do the job — a GPU, a package with no wasm wheel, or the native compiled path. r.where and r.why always tell you which happened.

Why it is fast

Native hot loops

Numeric functions are transpiled to Mojo by mojosub, compiled to a shared library, and dispatched in about a microsecond. 24–112x over CPython on loop kernels.

A cache everyone shares

Compiled units are content-addressed. The first person to submit a kernel pays the compile — on our clock, not their bill — and everyone after them gets native code from the first call.

Real CPython underneath

Anything outside the compilable subset just runs on CPython 3.13. Your imports are read out of your code and installed by uv — no packages field, no image to build. Nothing is rejected for being too dynamic.

Pricing

Where	Price	Notes
New account	1000 credits free	$1 of compute, once, no card
Your browser	free, always	WebAssembly CPython, never touches us
CPU	1 credit / 10000ms	$0.001 a credit — about $0.36 per core-hour
GPU	1 credit / 2000ms	RTX 5090, for when the kernel wants one
Queue, env builds, compiles	free	you are not billed for our infrastructure

Python, billed by themillisecond.