Quickstart

From sign-in to a cell running on a GPU in about five minutes. Nothing to install: the notebook, the terminal and the runtime all live in the browser.

1. Sign up and subscribe

Create an account at /signup with your email address and a password, confirm the verification code we email you, and accept the Terms and the Privacy Policy. Your account gets a personal workspace the moment it exists; every notebook, file and runtime below lives in that workspace. Already have an account? Sign in at /login.

Pro subscription. Neural Studio requires an active Pro subscription ($29 a month, 1,000 compute credits each cycle, a 250 GB storage pool shared by all your workspaces). After your first sign-in you land on the subscribe page; once the payment is confirmed you are taken to the dashboard. The account flows are on Your account and billing and the numbers on Limits.

2. Open a notebook

From the dashboard, choose New Notebook. A notebook is an ordinary .ipynb file in your workspace: it autosaves as you edit, shows up on the Files page, and opens in Jupyter, Colab, Kaggle or VS Code with nothing lost but the runtime it ran on.

The runtime bar at the top of the notebook is where you pick the machine.

3. Pick an environment and a machine

An Environment is a pre-built container image: a Python version plus the packages you listed, built once and reused by every runtime you launch on it. You do not have to build one to get started. The platform ships public templates you can launch straight away:

Every template is fully pinned, so a launch today and a launch next month run the same versions. When you outgrow a template, build your own on the Environments page, or let the platform turn a running session's installs into one (see Packages in your runtime).

Then choose the hardware in the runtime bar:

• Provider picks the cloud. The GPU classes on offer differ per cloud.
• GPU picks the class, how many GPUs, and, where the family sells more than one shape, the vCPU/RAM/NVMe size tier. Each row shows its rate in credits per hour; the rate you see is the rate you are charged. For a CPU runtime, pick a vCPU count instead.
• Spot launches a preemptible instance at the spot rate where the provider sells one. Cheaper, and reclaimable by the provider, so keep checkpoints in your workspace.
• Duration sets a hard stop. The picker preselects 30 minutes; choose ∞ for no hard deadline. The minimum is five minutes.
• Idle stop stops a runtime you have stopped using. It defaults to two hours and offers 15 minutes to 4 hours or Never; you can change it on a live session.

For a first GPU cell, the PyTorch + CUDA template on a single T4 is the cheapest useful choice.

4. Launch and run a cell

Press Start Runtime. The bar shows Finding a machine… while the cloud allocates an instance and Setting up machine… while the runtime boots and mounts your workspace. Provisioning time is never charged; the meter starts the moment the runtime is running. A GPU launch typically takes a few minutes.

When the bar shows the runtime as connected, put this in the first cell and run it with Shift+Enter:

!nvidia-smi

import torch
print(torch.__version__, torch.cuda.is_available(), torch.cuda.get_device_name(0))

The output streams into the cell as it is produced. The kernel runs as an ordinary user inside /home/user/workspace, which is your durable workspace filesystem: anything you write there is still there after the runtime stops, and everything else on the machine is discarded (see Isolation and secrets).

A few things that work the way you would hope:

• Closing the tab does not kill a running cell. Come back and the outputs produced while you were away replay into the cell.
• Restart kernel (notebook menu) replaces only the kernel process. The machine, the image, the workspace mount and anything you pip installed survive. Restart runtime (new VM) is the heavier option.
• The terminal (the terminal button in the runtime bar, View → Show terminal, or Ctrl+) opens a shell below the notebook on the same machine, as the same user. ssh, scp` and VS Code Remote-SSH work too; see SSH into your runtime.
• Install packages with a plain pip install in a cell or the terminal. They persist for the next runtime on the same Environment.

5. Stop when you are done

Press Stop in the runtime bar. A stopped runtime costs nothing; your workspace files and any packages you installed on the Environment persist. If Stop finds packages installed outside the image, it offers to save them as a new Environment first so the next launch starts with them baked in.

If you forget, the idle stop takes care of it: a runtime with no user interaction and no running cell for the idle period is stopped automatically. A cell that is still executing keeps the runtime alive.

Next: track a training run

The neural_studio SDK is preinstalled in every runtime and authenticates itself from inside a kernel, so a training loop can stream metrics to the Experiments page with three lines:

import neural_studio as ns

run = ns.init(name="resnet-baseline", config={"lr": 3e-4, "batch_size": 256}, tags=["baseline"])

for step, batch in enumerate(loader):
    loss = train_step(batch)
    run.log({"loss": loss, "lr": scheduler.get_last_lr()[0]}, step=step)

run.finish()  # also runs automatically at process exit

run.log never blocks on the network: points land in an in-memory ring and a background thread ships them in batches with retries, so a slow connection never slows the loop. Everything the process prints is captured to the run's Logs tab, run.watch(model) adds per-layer gradient and weight statistics for a torch.nn.Module, and run.log_artifact(...) attaches files.

run.log also takes images, tables and histograms, logged against a step like any metric, and every run page has a Media tab with a step slider:

run.log({
    "samples": [ns.Image(img.cpu().numpy(), caption=label) for img, label in examples],
    "predictions": ns.Table(columns=["id", "label", "score"], data=rows),
    "fc_weights": ns.Histogram(model.fc.weight),
}, step=step)

ns.Image takes a numpy array, PNG, JPEG or WebP bytes, a file path or a Pillow image (a tensor goes through .cpu().numpy()); ns.Table takes columns and data rows or a pandas dataframe=; ns.Histogram takes raw values or explicit counts and edges. The runtime image carries the SDK without its optional extras, so images from arrays, JPEG or WebP encoding and Pillow inputs need pip install numpy Pillow in a cell, never pip install "neural-studio[media]" inside a runtime. The caps are on the limits page.

From your own laptop or a cluster, the same code works with an API key in NEURAL_STUDIO_API_KEY plus the workspace id passed as workspace=; pip install neural-studio provides the package and the ns command line. mode="offline" records to a local spill file that ns sync replays later, which is what air-gapped training uses. Every argument, method and limit is on the SDK page.

Where to go from here

• Notebooks and runtimes: every control in the runtime bar and the notebook menus.
• Environments: build your own image from a template, a requirements.txt or a running session.
• Experiments and the Python SDK: charts, logs, system metrics, media and artifacts for every run.
• Sharing: give one person access, or mint a read-only link.
• Limits: what Pro includes, how billing works, and where the platform draws lines.
• Packages in your runtime: what persists across stop and start, and how to turn a session into an Environment.
• SSH into your runtime: VS Code, Cursor, rsync.
• Git in your runtime: git and gh are preinstalled, and commits strip notebook outputs by default.
• Isolation and secrets: what runs where, who can see what, and how to give a kernel an API key without pasting it into a notebook.