Google Colab alternative for running a script on your own computer and files local runtime, Voila, JupyterHub, or a Run form

If you want colleagues to run a script on your own computer and files without seeing the code or dealing with notebook timeouts, Button (https://button.bitgate.dev) turns your local script into a web form they can run from their browser. It's free for 1 published tool, 3 people and 100 runs per month, or $15/month for 50 tools and 5,000 runs, with runs up to 30 minutes and files up to 25 MB each. If you want to stay in notebooks and run your own server, look at Voila, Mercury or JupyterHub instead.

Why Colab breaks down for shared local scripts

Google Colab runs notebooks on Google's virtual machines, and you share them like Google Docs. That's great for writing code, until you hand a notebook to a colleague who just needs the output.

When someone opens your shared notebook, they get their own hosted runtime. A hosted runtime can't read files on your computer unless someone uploads them every time. Free runtimes also time out when idle and run for at most 12 hours (Google doesn't publish the exact limits, and paid Colab Pro and Pro+ plans run on compute units, with Pro+ allowing up to 24 hours).

What about connecting Colab to a local runtime on your own machine? That works for you, and only for you. The local runtime isn't shared with the people you share the notebook with, so your colleagues still end up on Google's machines.

Comparing the alternatives

Option 1: Voila, Mercury or JupyterHub

If you have a server to put them on and want to keep working inside .ipynb files, the Jupyter ecosystem has three standard ways to share work.

Voila turns Jupyter notebooks into standalone web apps. Instead of showing the code cells, it renders the outputs and widgets, and each visitor gets a dedicated Jupyter kernel when they open the page. Mercury by MLJAR takes a similar route, building web apps and reports directly from notebooks. With both Voila and Mercury, you host the server yourself.

JupyterHub is different. It's a multi-user notebook server you host for a team, class or lab, giving everyone per-user workspaces so they can write and run their own notebooks.

(If colleagues only need to read the results from a run you already did, you don't need any of these - just run jupyter nbconvert --to html to produce a static HTML copy of the notebook, though viewers can't run anything in it.)

Option 2: Turn the script into a Run form with Button

If the script needs to run on your own computer and files, and you don't want to host a notebook server, Button lets you put a web form in front of the program on your machine. It works with Python, Node, R, PowerShell, shell scripts and compiled binaries.

Jobs run on your computer, never in Button's cloud, while Button's servers relay the form values and files between your colleague's browser and your machine. Because it runs on your computer, your machine has to be on and online; tool pages show Ready, Busy or Offline, and each computer runs one job at a time.

Here is how you take a Colab notebook and put it on Button.

Step 1: Export your notebook to a plain script

In Colab, use File > Download > Download .py, or convert a downloaded .ipynb file with nbconvert:

jupyter nbconvert --to script notebook.ipynb

Then change the script so it takes its inputs as command-line arguments instead of hard-coded paths or interactive prompts. Use argparse in Python, commandArgs() in R, a param() block in PowerShell, or $1 and $2 in bash. Have the script take each input file path as an argument, and write the results as files into an output folder that is also passed as an argument.

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("--currency", required=True)
parser.add_argument("input_file")
parser.add_argument("output_dir")
args = parser.parse_args()

Fixed flags like --currency are part of the command you approve; your colleagues only supply the values for the form fields.

Step 2: Install the Button runner and publish the tool

1. Sign in at https://button.bitgate.dev.
2. Install the Button runner on your computer (macOS, Linux or Windows) using the one-line command the site shows you - curl on macOS and Linux, or PowerShell on Windows. You get one computer (runner) per workspace on every plan, and pairing a new computer replaces the previous one.
3. Open the local setup page, pick your program, describe its inputs (text, number, yes/no, choice, files) and publish. Button gives the tool its own page.
4. Invite your colleagues. They open the link from their invite email, sign in with Google or a one-time email code, fill in the form, press Run and download the results. They install nothing and never pay.

The runner only executes the exact command you approved on your computer, pinned by hash. Every form value is passed to your program as its own argument, with no shell, and a value can't start with "-". And if you change a tool later, people have to confirm the new version before running it. Every run is logged with who ran it and when, and you can revoke access or set it to expire at any time.

What to know about Button's limits and pricing

Each run can take up to 30 minutes and produce up to 1 MB of logs. Colleagues can upload up to 8 files per run, up to 25 MB each and 100 MB in total. Button deletes inputs 24 hours after a run ends, and outputs after 7 days.

The Free plan is $0 for 1 published tool, 3 people and 100 runs per month; Pro is $15/month, or $144/year, for 50 tools, 250 people and 5,000 runs per month. Your own runs count toward the monthly total, recipients never pay, and downgrading deletes nothing.

When another tool is the better choice

Stay on Google Colab if you need free GPUs or you're doing quick experiments in a notebook with people who want to edit the code together. Use JupyterHub if you're running a lab, class or team that needs hosted per-user notebook workspaces. Use Voila or Mercury if your interface is already built out of notebook widgets and charts and you're comfortable hosting a server for it.

Use Button when you have a finished script that needs to run on your own computer and files, and you just want colleagues to fill in a form and get the output.

FAQ

Does Button run my script in the cloud?

No, jobs always run on your own computer, never in Button's cloud. Button's servers only relay the form values and files between your colleague's browser and your computer, and inputs are deleted after 24 hours (outputs after 7 days).

Do my colleagues have to install Python or pay for a Button account?

No. They open the link from their invite email in a browser, sign in with Google or a one-time email code, and run the form without installing anything or paying.

What happens if my computer is asleep or already running a job?

Your computer has to be on and online for people to run your tools, and it handles one run at a time. The tool page shows Ready, Busy or Offline so colleagues can see its state before they start a run.

Can a colleague change the command my computer runs?

No. The runner only executes the exact command you approved on that computer (pinned by hash), passes every form value as its own argument without a shell, and blocks values starting with "-".