JupyterLab, on your own GPU.

The simplest Google Colab alternative is a GPU VM you rent by the hour, with JupyterLab already running on it. QuantaCloud's PyTorch + Jupyter template gives you exactly that: JupyterLab in your browser, PyTorch with GPU support, an NVIDIA GPU with 48 to 141 GB of memory that you choose, and SSH to the same machine. It does not stop when you go idle, and it does not keep your files after you stop it.

A single RTX A6000 with 48 GB runs from $0.48/GPU-hr. You pay from launch to stop: the first hour is charged at launch, and the unused seconds of the current hour are refunded when you stop. Prices checked 6 Oct 2026, 01:25 UTC

Colab and a rented GPU, side by side#

The core difference is who picks the GPU and who ends the session. Colab assigns GPUs from a pool that changes over time and ends idle sessions. On QuantaCloud you choose the GPU, and the session ends when you stop it. The Colab column below comes from Colab's FAQ and its US pricing page on 2026-09-28.

How long a Colab compute unit lasts depends on the machine and accelerator you pick, so the two price models do not convert one to one. The Colab pricing comparison works through when each one is cheaper.

When Colab is still the better choice#

Colab still wins for small, short work that already lives in Google Drive. For a course notebook, a quick experiment or anything a free session finishes, launching a VM is more ceremony than the job deserves, and Colab costs nothing. It also shares a notebook as easily as a Google Doc.

A rented GPU wins when the run needs more than Colab's session limits, a known GPU with a known amount of memory, a shell, or an environment you control. Those are the moments I would move: a fine-tune that has to finish overnight, a model that needs 48 GB or more, or a job that needs tmux and ssh as much as it needs a notebook.

Pick a GPU for the job#

GPU memory decides what fits, so pick it from the model size and the method. Unsloth's published minimums give a sense of scale for fine-tuning:

Today's prices for these GPUs:

For the numbers method by method, see LoRA vs QLoRA vs full fine-tuning VRAM, and for inference and everything else, how much VRAM you need.

Start JupyterLab in four steps#

Four steps take you from the Deploy button to a notebook on the GPU.

1. Launch the PyTorch + Jupyter template on the GPU you picked. If you add credit on the way, check that the template still reads PyTorch + Jupyter before you click Deploy. The templates docs describe all four templates.

2. Wait for Running on the Deployments page. Most single-GPU VMs are running in about 3 minutes (median), and app templates take longer: the deployment stays in Connecting while the app's container image is pulled and until JupyterLab answers its health check.

3. Click Open Application. JupyterLab opens behind your QuantaCloud login, only for the account that launched the instance, and there is no Jupyter token to copy.

4. Check the GPU in the first cell:

   PythonCopy

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

   Install anything else from a cell with %pip install, for example %pip install transformers.

Save your work before you stop#

Stopping deletes the instance and its disk: notebooks, outputs, checkpoints and everything you installed with %pip go with it. QuantaCloud has no volumes or snapshots, so treat every session as disposable and copy results off as you go.

For a handful of files, use JupyterLab itself: right-click a file in the file browser and choose Download. For a folder, open a terminal from the Launcher, pack it with tar czf results.tgz results/, and download the archive.

For large files, use SSH. JupyterLab runs in a container on the VM, the one that publishes port 8888, so copy the files out of the container first, then pull them to your laptop. Run %pwd in a notebook to see the folder your notebooks live in, and put that path where the command says <notebook-folder>:

ssh -i ~/.ssh/your_key ubuntu@<instance-ip>
C=$(sudo docker ps -q --filter publish=8888)
sudo docker cp "$C":<notebook-folder> ./work
sudo chown -R ubuntu: ./work

Then, from your laptop:

rsync -avz -e "ssh -i ~/.ssh/your_key" ubuntu@<instance-ip>:work/ ./work/

Two habits make a fresh instance quick to set up: keep a requirements.txt next to your notebooks and install it in the first cell, and download models and datasets at the start of each session instead of carrying them over. The Hugging Face download guide shows the fast way to do that.

What it costs#

You pay for the time from launch to stop, boot included, and the template adds nothing to the price. The first hour is charged at launch, each further hour when the previous one is used up, and stopping refunds the unused seconds of the current hour. A four-hour session on a single RTX A6000 costs 4 x $0.48 = $1.92 at the price on 2026-09-27 (our calculation). Today's price is $0.48/GPU-hr.

The flip side of no idle timeout is that an idle notebook keeps billing until you press Stop. If your balance cannot cover the next hour, QuantaCloud terminates the instance and deletes its disk. A low-balance email goes out when the balance drops below $2, and auto top-up is optional. The pricing page has the full rules.

Questions before you switch#

Is there a free tier?

No. You add prepaid credit from a $5 minimum, and the first hour is charged when the instance launches. A short test costs a fraction of an hour: 20 minutes from launch to stop on an RTX A6000 costs 20/60 x $0.48 = $0.16 at the price on 2026-09-27, after the refund on stop (our calculation). Today's price is $0.48/GPU-hr.

Colab vs Jupyter: what is the difference?

Colab is a hosted service built on Jupyter, the open-source project. JupyterLab is Jupyter's own interface, and this template runs it on a GPU you rent. Both use the .ipynb notebook format, so notebooks move between them as files.

Can I use VS Code instead of the browser?

Yes, over SSH. VS Code's Remote - SSH extension connects to the instance as ubuntu, and the SSH and VS Code guide sets it up. If VS Code is your main editor, the Bare Metal template with your own environment is the cleaner route.

Which PyTorch and CUDA versions does it run?

The first cell above prints both. The template is updated over time, so check at the start of a session, and see checking your driver and CUDA version for the driver side.

My rule: stay on Colab while your work fits its free sessions on whatever GPU it assigns you. Move to a rented GPU when a run needs more time than Colab allows, a known amount of memory, or a shell. Launch the PyTorch + Jupyter template on an RTX A6000, check the GPU in the first cell, and download your results before you stop.