Quickstart

From sign-up 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. Create an account

Go to /signup and sign up with an email address and a password. You verify the address before the first sign-in. (Sign-in with Google or GitHub is not available yet.) Your account gets a personal workspace the moment it exists; every notebook, file and runtime below lives in that workspace.

Welcome credits. New accounts start with 1,000 credits ($10 of compute), granted once per account and valid for 30 days. No card is needed; the grant lands the first time your account touches billing, which includes your first launch. See Limits and free credits for the fine print.

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:

TemplateWhat is in it
BlankPython and JupyterLab, nothing else.
Data ScienceNumPy, pandas, scikit-learn, Matplotlib (CPU).
PyTorch + CUDAPyTorch and torchvision with CUDA for GPU runtimes.
HuggingFace NLPTransformers, Datasets and Accelerate for language models on GPU.
Computer VisionPyTorch, torchvision, OpenCV and Pillow for image and video models on GPU.
JAX + FlaxJAX with Flax and Optax on GPU.
Reinforcement LearningGymnasium and Stable-Baselines3 on PyTorch on GPU.

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 at the bottom of the notebook is a shell 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.

From your own laptop or a cluster, the same code works with a full-access API key from Settings → API Keys 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.

Where to go from here