Lupine Cloud GPU for VS Code

Run CUDA Python workloads from the editor, even when your workspace machine has no GPU.

Lupine Cloud gives CPU-only development environments access to on-demand NVIDIA GPUs. Your Python process, source code, and virtual environment stay in your VS Code workspace while Lupine forwards CUDA calls over an encrypted connection to a cloud GPU.

It is a practical way to attach a GPU to GitHub Codespaces, a development container, a remote VPS, WSL, or your local machine without moving your project to a separate GPU environment.

What you can do

Run the active Python file on a Lupine GPU from the editor toolbar, Command Palette, or file context menu.
Keep using the Python environment and dependencies already configured in your workspace.
Use uv projects automatically. The extension recognizes uv.lock and runs the file with uv run or the project's synced .venv.
Sign in through your browser without copying tokens into VS Code.
Install the Lupine CLI directly into the remote workspace when it is not already available.
Select a GPU type, region, and script arguments through VS Code settings.
Follow output and stop a run through the normal VS Code task terminal.

Quick start

Open a folder containing a Python project.
Make sure the project's environment contains the packages your script uses. For example:
```
uv add torch
```
Open a saved .py file.
Select Run Python File with Lupine from the editor toolbar or Command Palette.
Accept the CLI installation and browser sign-in prompts when they appear.

Lupine selects an available GPU, starts the file in your workspace environment, and streams its output to the task terminal.

import torch

device = torch.device("cuda")
print(torch.cuda.get_device_name(0))

x = torch.randn(2048, 2048, device=device)
print((x @ x).sum())

How it works

Python in your workspace
        |
        | CUDA calls over HTTPS
        v
Lupine regional gateway
        |
        v
Cloud NVIDIA GPU

On Linux, Lupine starts the selected local Python interpreter and loads its CUDA client shims into that process. The application keeps using its own Python packages and CUDA runtime while GPU operations execute remotely.

This means Lupine supplies the GPU, not your Python dependencies. If a script imports PyTorch, JAX, or another CUDA framework, install a CUDA-enabled build of that package in the workspace environment first.

Workspace environments

Linux, Codespaces, WSL, Dev Containers, and Remote SSH

For a project containing uv.lock, the extension uses uv run when uv is on the VS Code extension host's PATH. Otherwise, it uses the project's synced .venv/bin/python. Run uv sync after changing project dependencies.

For other projects, the extension uses the interpreter selected by the Microsoft Python extension. If that extension is unavailable, it falls back to python3. An explicit Lupine: Python Path setting takes precedence over both choices.

The Lupine extension and CLI run on the machine that owns the workspace. In a Codespace or Remote SSH window, that means the remote machine rather than your desktop.

macOS

macOS has no native CUDA driver, so the extension runs the workload in Lupine's Linux sidecar through Docker. The workspace is mounted at /workspace, and the sidecar includes a CUDA-enabled PyTorch environment.

A Python virtual environment created on macOS cannot be used inside the Linux sidecar. Any Lupine: Python Path override must name an executable available inside the sidecar.

Windows

Automatic CLI installation is currently available on Linux and macOS. On Windows, install the Lupine CLI separately and set Lupine: Executable Path if it is not on PATH.

Commands

Command	Purpose
Lupine: Run Python File with Lupine	Run the current saved Python file with a cloud GPU.
Lupine: Sign In	Authenticate the workspace's Lupine CLI through your browser.
Lupine: Install CLI	Install or reinstall the managed Lupine CLI for this workspace environment.

Settings

Setting	Purpose
`lupine.executablePath`	Path to the Lupine CLI. Defaults to `lupine`, then falls back to the extension-managed installation.
`lupine.pythonPath`	Python executable to use instead of automatic `uv` or interpreter detection.
`lupine.gpu`	GPU SKU to request. Empty uses the Lupine default.
`lupine.region`	GPU region to request. Empty uses the nearest available region.
`lupine.scriptArgs`	Arguments appended to the Python file invocation.

Troubleshooting

`ModuleNotFoundError`

The package is missing from the Python environment shown in the task command. Install it in that environment, select the intended interpreter, or add it to the project's pyproject.toml and run uv sync.

The Lupine CLI was not found

Run Lupine: Install CLI. For a remote workspace, install it on the remote machine. You can also set Lupine: Executable Path to an existing executable.

Authentication is required

Run Lupine: Sign In. The extension opens the login page using VS Code and waits for the CLI to save its credentials. The extension does not store the token itself.

A file cannot be run

The file must be saved, use the .py extension, and belong to an open workspace folder.

Extension development

From clients/vscode in the Lupine repository:

npm install
npm test

Press F5 in VS Code to compile the extension and open an Extension Development Host. For local CLI development, mise run build:cli writes bin/lupine; set Lupine: Executable Path to that absolute path.

Lupine Cloud GPU

Lupine Machines