Contents
Figure 1: Best Cloud Notebook Services for Running GitHub Projects — a data center aisle you get to borrow for a few hours, which is exactly what a free notebook tier is
You found a promising repo: a model, a tutorial, a paper's code. The README says "run the notebook," and your laptop has no GPU, the wrong Python version, and a half-broken CUDA install. Cloud notebooks solve exactly that: open the repo in a browser, get a machine with a GPU, and run the project without touching your own setup. The services differ a lot in free limits, persistence, GitHub integration, and how much of the environment you actually control.
Free tiers change constantly, so I quote few figures and name where to verify each one. Everything below reflects what the providers' own pages said in early November 2026, and the numbered brackets point to those pages at the end.
What to Compare
For running someone else's GitHub project, these factors matter more than benchmark scores:
- GitHub integration: can you open a repo's notebook in one click, or must you clone it yourself?
- GPU access and limits: which GPUs, for how long, and with what guarantees?
- Persistence: do files, packages, and the environment survive a restart?
- Environment control: can you choose the Python version, install system packages, or supply a Docker image?
- Session length and idle timeouts: will a real training run finish?
- Secrets and data access: how do keys and datasets get in, and where do they leak out?
- Cost: what is free, what happens at the limit, and what does the next tier cost?
- Stability: free products close. Check before you build a workflow around one.
Google Colab: The Default
Colab is still the fastest path from a GitHub URL to a running notebook. For public repos that ship a notebook, nothing else is as quick: paste the URL pattern and the file opens in a tab.
https://colab.research.google.com/github/OWNER/REPO/blob/main/notebooks/demo.ipynb
Repo authors usually wrap that in a badge, which is the link to click when you see one in a README:
[](https://colab.research.google.com/github/OWNER/REPO/blob/main/notebooks/demo.ipynb)
The limits are the trade-off. Free notebooks run for at most 12 hours, depending on availability and usage patterns, and the runtime is deleted when it sits idle [1]. GPU access is not guaranteed at all — at peak times a free session gets a CPU machine [1]. Colab also describes itself as interactive compute, and long background jobs on GPUs can be terminated [1].
Paid plans stretch this: Pro+ supports continuous execution for up to 24 hours while you have compute units [1]. If you only need one-click convenience, the free tier is enough. If you need a run to finish unattended, it is not.
I walked through the full Colab setup, including the GPU check and the %cd trap, in how to run any GitHub ML repo in Colab.
Kaggle Notebooks: The Predictable Quota
Kaggle is the service that tells you what you get. Its own docs describe a weekly GPU quota that resets each week and is 30 hours or sometimes higher depending on demand [2]. Sessions run up to 12 hours on CPU or GPU and 9 hours on TPU, with a P100 or two T4s as the free accelerators [2].
That combination — a stated budget, long sessions, and free datasets — makes Kaggle the better choice for a training run you actually want to finish. The catch is the environment: you get Kaggle's image, not a container you control, and interactive sessions stop after a short idle period, so long jobs should use Save & Run All rather than a browser tab you keep alive.
Importing from GitHub is the weak spot. Kaggle's GitHub integration has changed repeatedly, so do not trust a tutorial's menu path. The reliable route is the same as anywhere else: clone the repo in a cell, or upload the .ipynb and its supporting files.
Lightning AI Studios: A Persistent Workspace
Lightning sells itself as a full IDE rather than a notebook tab, and the free tier is unusually concrete. The pricing page lists one free Studio that runs 24/7 but restarts every four hours, 50 GB of persistent storage, and up to 30 credits to start — which the FAQ equates to roughly 50 GPU hours on interruptible machines [3]. A T4 lists at roughly $0.55 to $0.88 an hour once credits run out, depending on the instance type [3].
That persistence is the differentiator. Your files and installed packages survive a restart, which is the thing Colab and Kaggle cannot offer on the free tier. You also get a terminal, SSH, and VS Code-style tooling, so a repo that expects a normal shell works better here than in a notebook cell.
The trade-off is that free capacity is interruptible and the credit model takes reading. Check the current pricing page before you plan around any number, including the ones above.
GitHub Codespaces: Dev Containers, Not Notebooks
Codespaces runs a development container for a repository, with VS Code in the browser. It respects a repo's .devcontainer configuration, which makes environment setup repeatable in a way no notebook service matches.
Personal accounts get 120 core-hours of compute and 15 GB-months of storage per month on the Free plan, rising to 180 and 20 on Pro [4]. Core-hours are not wall-clock hours: a 4-core machine burns four per hour, so the allowance is smaller than it looks.
The machine picker offers CPU machines only, so Codespaces is for code-first repos — scripts, tests, CLI tools, web apps — not for training. Where it shines is a repo with a devcontainer and a test suite: you get the same environment every time, and you can debug it like a normal project.
Binder: No Account, No GPU
Binder builds a repository into a temporary environment and opens JupyterLab with no sign-in. It is free, CPU-only, and completely ephemeral, and it only works when the repo declares its environment through requirements.txt, environment.yml, or a Dockerfile.
[](https://mybinder.org/v2/gh/OWNER/REPO/HEAD?labpath=notebooks%2Fdemo.ipynb)
Use it for a five-minute demo of a small CPU project, not for anything you need to keep. The build can take minutes, and the session disappears when it idles out.
Paperspace, Deepnote, and the Rest
A few more names show up in every "free GPU" list, and each needs a caveat:
- Paperspace Gradient is now part of DigitalOcean. Free GPU availability has always been capacity-dependent, so check the current offer rather than a 2025 listicle.
- Deepnote publishes comparison pages that position it against Colab and Kaggle — read those as marketing. Its real selling point is collaboration and shared environments for teams.
- Hugging Face Spaces runs app repos (Gradio and Streamlit demos), which is a different workflow from executing a notebook. Good for showing a model, not for training one.
- Saturn Cloud appears in free-tier roundups; verify what the free plan includes before you migrate a workflow.
SageMaker Studio Lab Is Closed
Older guides still recommend Amazon SageMaker Studio Lab as a free GPU notebook. AWS's own documentation now says it is no longer open to new customers, though existing users can continue [5].
If a tutorial tells you to sign up, that tutorial is out of date. This is the clearest argument for checking the provider's page instead of a comparison post — including this one, eventually.
Hyperscaler Notebooks Cost Real Money
SageMaker Studio, Vertex AI Workbench, and Azure Machine Learning all offer managed notebooks with real governance, private networking, and identity integration. They are enterprise-priced infrastructure, not a Colab replacement: a GPU instance bills by the hour, and the meter runs while the notebook is idle unless you configure auto-shutdown.
That is fine when a team needs audit logs and a VPC. It is the wrong tool for running a random repo on a Saturday.
Quick Picks
- Easiest one-click start for a public repo: Google Colab [1]
- Most predictable free GPU budget: Kaggle Notebooks [2]
- Persistent workspace with SSH and a terminal: Lightning AI Studios [3]
- Repeatable dev environments from a devcontainer: GitHub Codespaces [4]
- No-account CPU demo: Binder
- Team collaboration: Deepnote and similar commercial notebooks
- Enterprise governance: SageMaker Studio, Vertex AI, Azure ML
- Do not start here anymore: SageMaker Studio Lab [5]
Most people should keep two accounts: Colab for convenience, and Kaggle or Lightning for the runs that need to survive a browser tab closing.
How to Run a GitHub Project: A Reusable Recipe
Whichever service you pick, the steps barely change:
- Read the README and any
requirements.txt,environment.yml, orDockerfilefirst. - Open or clone the repo. Use the service's GitHub integration, or clone in a cell.
- Pin the version. Check out a tag or commit so the code cannot change under you.
- Install dependencies, preferring the service's existing stack where possible.
- Check the GPU before you run anything heavy.
- Run small, then save outputs to durable storage.
Here is the starter cell I use on Colab or Kaggle (the ! lines run shell commands, the % lines are notebook magics):
!git clone https://github.com/OWNER/REPO.git
%cd REPO
!git checkout TAG_OR_COMMIT # pin for reproducibility
%pip install -q -r requirements.txt
import torch
print("CUDA available:", torch.cuda.is_available())
!nvidia-smi
The %cd matters. A plain !cd runs in a subshell and changes nothing for the next cell.
After installing, some services need a runtime restart before the new package versions load. If imports fail right after a successful install, restart and rerun before you debug anything else.
Handle Dependency Conflicts
Cloud notebooks ship with preinstalled libraries, and a repo's pins will sometimes fight them. Work through this order:
- Install into the existing environment and restart the runtime.
- Create a fresh virtual environment when the repo needs exact versions.
- Use the repo's Dockerfile or devcontainer on services that support them.
- Match the Python version the repo expects, when the service lets you choose.
The most common cause is not a version conflict at all — it is installing into the wrong interpreter. Use %pip in notebooks, and python -m pip in scripts, so the package lands where the kernel can see it.
Keep Your Work
Free sessions end, and the disk usually goes with them. Save checkpoints and outputs somewhere durable: Google Drive, an S3 bucket, or the Hugging Face Hub for model weights.
On services with persistent disks, such as Lightning's Studios [3], check the storage cap before you fill it. Copy checkpoints after each epoch, not at the end — disconnects do not warn you, and a session that dies at hour five takes the last five hours with it.
Safety: Notebooks Run Arbitrary Code
A GitHub notebook is a program. Running it in your cloud account executes whatever its author, or a compromised dependency, wrote. Treat an unfamiliar repo like unknown software:
- Skim the code and the install steps before running them, especially cells that download and execute a script.
- Do not mount your personal cloud drive into a session running a repo you do not trust.
- Keep secrets in the service's secret store, and use throwaway tokens with minimal scope.
- Be careful with
pip installfrom unfamiliar sources and with prebuilt binaries. - Pin to a reviewed commit, not a moving branch.
- Use a separate account for experiments that touch anything sensitive.
Colab and Kaggle both offer secret storage, and Colab's userdata module is the one I use most. Never paste a key into a cell you might share — notebook outputs are saved, exported, and screenshotted.
Common Pitfalls
- Running a repo without reading it. Notebooks execute code. Read first.
- Forgetting to save outputs. The session ends and the files vanish.
- Skipping version pins. The repo moves and your notebook breaks.
- Ignoring the GPU check. A silent CPU fallback wastes hours.
- Trusting old tutorials. Studio Lab is the cautionary example [5].
- Putting API keys in cells. Use secrets, and rotate anything already exposed.
- Choosing one service for everything. Match the tool to the job.
- Assuming free means stable. Free products close, and quotas change without notice.
Best Book to Read
| Cover | Book | Description | Get it |
|---|---|---|---|
![]() |
Machine Learning Engineering | how to take a model past the notebook: environments, data pipelines, reproducibility, and the operational habits these services assume you have. | View on Amazon |
As an Amazon Associate I earn from qualifying purchases. Links on this page are affiliate links, and I may earn a commission at no extra cost to you.
Read it after your first successful cloud run, when the gaps between "it works in a notebook" and "it works" are fresh.
Wrapping Up
For one-click runs of public GitHub notebooks, Colab is the easiest start. For a predictable free GPU budget, Kaggle is hard to beat. Lightning's Studios give you a persistent workspace if you can live with its credit model, and Codespaces is the right answer for code-first repos with a devcontainer.
Skip anything closed to new users, and treat every unfamiliar repo as code you are choosing to run. Pick one service, run one repo end to end, and write down what broke — that single exercise teaches more about environments than any comparison table, including this one.
Frequently Asked Questions
Is Colab or Kaggle better for running GitHub repos?
Colab is better when the repo ships a notebook, because you can open it from the GitHub URL in one click. Kaggle is better when you need a known GPU budget: it documents a weekly quota, while Colab's free GPU access varies with demand.
Can I run a repo that has a Dockerfile in a cloud notebook?
Only on services that accept a container image or a devcontainer, such as GitHub Codespaces and Lightning AI Studios. Colab and Kaggle give you their own base image, so you install dependencies inside it instead.
Do free cloud notebooks keep my files between sessions?
Usually not. Colab and Kaggle delete the working disk when the session ends, so mount Drive or another bucket and copy checkpoints out. Persistent storage is a paid feature on Lightning and the hyperscalers.
Are cloud notebooks safe for private code and data?
Treat a notebook as arbitrary code running in your account. Read the repo before you run it, keep secrets in the service's secret store, do not mount personal storage into untrusted sessions, and use a throwaway account for experiments.
Which free service needs no credit card?
Colab and Kaggle both work with only a Google account. Lightning's free tier is also card-free to start, but it gives you a limited credit balance and one Studio that restarts every four hours.
Sources
[1]Google Colab, Frequently Asked Questions — 12-hour free ceiling, idle deletion, GPU availability, interactive-use policy, Pro+ execution: research.google.com/colaboratory/faq.html[2]Kaggle, Efficient GPU usage — weekly GPU quota, accelerators, session limits: kaggle.com/docs/efficient-gpu-usage[3]Lightning AI, Pricing — free credits, Studio restarts, persistent storage, hourly rates: lightning.ai/pricing[4]GitHub Docs, Billing for GitHub Codespaces — free compute and storage allowance: docs.github.com/en/billing/concepts/product-billing/github-codespaces[5]AWS, Amazon SageMaker Studio Lab — notice that the service is closed to new customers: docs.aws.amazon.com/sagemaker/latest/dg/studio-lab.html
