modal-cuda-runner 0.1.0__tar.gz

modal_cuda_runner-0.1.0/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Corbin Platti
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OF OTHER DEALINGS IN THE
+SOFTWARE.</content>
+</invoke>

modal_cuda_runner-0.1.0/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: modal-cuda-runner
+Version: 0.1.0
+Summary: Run CUDA files on Modal from your local machine
+Author-email: Corbin Platti <csplatti@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/csplatti/modal-cuda-runner
+Project-URL: Repository, https://github.com/csplatti/modal-cuda-runner
+Project-URL: Issues, https://github.com/csplatti/modal-cuda-runner/issues
+Keywords: cuda,modal,gpu,nvcc,cli
+Classifier: Programming Language :: Python :: 3
+Classifier: Environment :: GPU :: NVIDIA CUDA
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: System :: Distributed Computing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: modal>=1.0
+Requires-Dist: rich>=13.0
+Dynamic: license-file
+
+# mcr — Modal CUDA Runner
+
+Run a CUDA `.cu` file on an NVIDIA GPU from Modal, from anywhere on your machine, in one command. No local GPU required.
+
+## Install
+
+```
+pip install git+https://github.com/<your-handle>/modal-cuda-runner
+modal setup   # one-time Modal authentication
+```
+
+## Usage
+
+```
+$ mcr test.cu
+→ Running test.cu on T4
+  GPU: Tesla T4
+  Vector length: 1048576
+  Errors: 0
+  Sample: c[0]=3.0 c[1048575]=3.0
+✓ Finished executing on Modal (3.42s)
+```
+
+Pick a different GPU with `--gpu`:
+
+```
+mcr test.cu --gpu H100
+```
+
+Supported: `T4` (default), `L4`, `A10G`, `A100`, `A100-80GB`, `H100`.
+
+The CUDA program's stdout is forwarded to your stdout and its exit code becomes `mcr`'s exit code, so `mcr` composes cleanly with shell pipes and CI.
+
+## How it works
+
+`mcr` reads your `.cu` file locally and sends the **source as a function argument** to a Modal function running an `nvidia/cuda:12.9.0-devel-ubuntu22.04` image. Because the image never changes across invocations, Modal caches it forever — no per-run image rebuild.
+
+On the remote container: `nvcc` compiles the source, then the resulting binary runs on the requested GPU. stdout streams back as it's produced.
+
+- First run: slower — container cold start on Modal's side.
+- Subsequent runs: typically a few seconds for small kernels.
+
+## Not yet supported
+
+Intentionally scoped small for v1:
+- Multi-file projects / `.cuh` headers
+- Passing CLI args or stdin to the CUDA binary
+- Custom `nvcc` flags

modal_cuda_runner-0.1.0/README.md

@@ -0,0 +1,48 @@
+# mcr — Modal CUDA Runner
+
+Run a CUDA `.cu` file on an NVIDIA GPU from Modal, from anywhere on your machine, in one command. No local GPU required.
+
+## Install
+
+```
+pip install git+https://github.com/<your-handle>/modal-cuda-runner
+modal setup   # one-time Modal authentication
+```
+
+## Usage
+
+```
+$ mcr test.cu
+→ Running test.cu on T4
+  GPU: Tesla T4
+  Vector length: 1048576
+  Errors: 0
+  Sample: c[0]=3.0 c[1048575]=3.0
+✓ Finished executing on Modal (3.42s)
+```
+
+Pick a different GPU with `--gpu`:
+
+```
+mcr test.cu --gpu H100
+```
+
+Supported: `T4` (default), `L4`, `A10G`, `A100`, `A100-80GB`, `H100`.
+
+The CUDA program's stdout is forwarded to your stdout and its exit code becomes `mcr`'s exit code, so `mcr` composes cleanly with shell pipes and CI.
+
+## How it works
+
+`mcr` reads your `.cu` file locally and sends the **source as a function argument** to a Modal function running an `nvidia/cuda:12.9.0-devel-ubuntu22.04` image. Because the image never changes across invocations, Modal caches it forever — no per-run image rebuild.
+
+On the remote container: `nvcc` compiles the source, then the resulting binary runs on the requested GPU. stdout streams back as it's produced.
+
+- First run: slower — container cold start on Modal's side.
+- Subsequent runs: typically a few seconds for small kernels.
+
+## Not yet supported
+
+Intentionally scoped small for v1:
+- Multi-file projects / `.cuh` headers
+- Passing CLI args or stdin to the CUDA binary
+- Custom `nvcc` flags

modal_cuda_runner-0.1.0/mcr/cli.py

@@ -0,0 +1,99 @@
+import argparse
+import pathlib
+import sys
+import time
+import modal
+
+# Relative import (`from .remote`) instead of `from mcr.remote`
+from .remote import app, run_cuda
+from rich.console import Console
+from rich.progress import Progress, ProgressColumn, SpinnerColumn, TextColumn
+from rich.text import Text
+
+# `Console(stderr=True)` sends all cosmetic output to stderr so the CUDA
+# program's own stdout stays clean
+console = Console(stderr=True)
+
+class _SecondsElapsedColumn(ProgressColumn):
+    def render(self, task) -> Text:
+        elapsed = task.elapsed
+        if elapsed is None:
+            return Text("--", style="cyan")
+        return Text(f"{elapsed:.2f}s", style="cyan")
+
+# Hardcoded GPU list. Modal doesn't expose a "valid GPUs" API, so typos would
+# otherwise fail at Modal call time — after you've already waited on a container.
+GPU_CHOICES = ["T4", "L4", "A10G", "A100", "A100-80GB", "H100"]
+
+def main() -> None:
+    args = receive_args().parse_args()
+
+    path = pathlib.Path(args.file)
+    if not path.is_file():
+        print(f"mcr: {path}: no such file", file=sys.stderr)
+        sys.exit(1)
+
+    source = path.read_text()
+
+    fn = run_cuda if args.gpu == "T4" else run_cuda.with_options(gpu=args.gpu)
+
+    try:
+        result, elapsed = run_on_modal(args, path, source, fn)
+        print_oneline_summary(result, elapsed)
+
+
+        sys.stdout.write(result["stdout"])
+        sys.stderr.write(result["stderr"])
+        sys.exit(result["returncode"])
+    except modal.exception.AuthError:
+        console.print("[red]✗[/red] Not logged in to Modal. Run [cyan]modal setup[/cyan] to authenticate.")
+        sys.exit(1)
+
+
+def run_on_modal(args, path, source, fn):
+    console.print(
+        f"[dim]→[/dim] Running [cyan]{path.name}[/cyan] on [magenta]{args.gpu}[/magenta]"
+    )
+
+    start = time.monotonic()
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[cyan]Executing on Modal..."),
+        _SecondsElapsedColumn(),
+        console=console,
+        transient=True,
+    ) as progress:
+        progress.add_task("", total=None)
+        with app.run():
+            result = fn.remote(source, filename=path.name)
+    elapsed = time.monotonic() - start
+    return result, elapsed
+
+def receive_args():
+    parser = argparse.ArgumentParser(
+        prog="mcr",
+        description="Compile and run a CUDA source file on Modal.",
+    )
+    parser.add_argument("file", help="path to a .cu source file")
+    parser.add_argument(
+        "--gpu",
+        default="T4",
+        choices=GPU_CHOICES,
+        help="GPU to run on (default: T4)",
+    )
+    
+    return parser
+
+def print_oneline_summary(result, elapsed):
+    if result["stage"] == "compile" and result["returncode"] != 0:
+        console.print(
+            f"[red]✗[/red] Compile failed (exit {result['returncode']}) ({elapsed:.2f}s)"
+        )
+    elif result["returncode"] != 0:
+        console.print(
+            f"[yellow]✗[/yellow] Exited with code {result['returncode']} ({elapsed:.2f}s)"
+        )
+    else:
+        console.print(
+            f"[green]✓[/green] Finished executing on Modal ({elapsed:.2f}s)"
+        )

modal_cuda_runner-0.1.0/mcr/remote.py

@@ -0,0 +1,61 @@
+import modal
+import pathlib
+import subprocess
+import tempfile
+
+cuda_image = (
+    modal.Image.from_registry(
+        "nvidia/cuda:12.9.0-devel-ubuntu22.04",
+        add_python="3.11",
+    )
+    .run_commands("rm -rf /opt/nvidia/entrypoint.d")
+)
+
+app = modal.App("mcr")
+
+
+@app.function(image=cuda_image, gpu="T4")
+
+def run_cuda(source: str, filename: str = "kernel.cu") -> dict:
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmp = pathlib.Path(tmpdir)
+        src_path = tmp / filename
+        bin_path = tmp / "a.out"
+        src_path.write_text(source)
+
+        compile_proc = subprocess.run(
+            ["nvcc", str(src_path), "-o", str(bin_path)],
+            capture_output=True,
+            text=True,
+        )
+
+        if compile_proc.returncode != 0:
+            return {
+                "stage": "compile",
+                "stdout": compile_proc.stdout,
+                "stderr": compile_proc.stderr,
+                "returncode": compile_proc.returncode,
+            }
+
+        run_proc = subprocess.Popen(
+            [str(bin_path)],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+            errors="replace",
+        )
+        PREVIEW_ON = "\033[2;36m"
+        PREVIEW_OFF = "\033[0m"
+        captured = []
+        for line in run_proc.stdout:
+            captured.append(line)
+            print(f"{PREVIEW_ON}  {line.rstrip()}{PREVIEW_OFF}", flush=True)
+        run_proc.wait()
+
+        return {
+            "stage": "run",
+            "stdout": "".join(captured),
+            "stderr": "",
+            "returncode": run_proc.returncode,
+        }

modal_cuda_runner-0.1.0/modal_cuda_runner.egg-info/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: modal-cuda-runner
+Version: 0.1.0
+Summary: Run CUDA files on Modal from your local machine
+Author-email: Corbin Platti <csplatti@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/csplatti/modal-cuda-runner
+Project-URL: Repository, https://github.com/csplatti/modal-cuda-runner
+Project-URL: Issues, https://github.com/csplatti/modal-cuda-runner/issues
+Keywords: cuda,modal,gpu,nvcc,cli
+Classifier: Programming Language :: Python :: 3
+Classifier: Environment :: GPU :: NVIDIA CUDA
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: System :: Distributed Computing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: modal>=1.0
+Requires-Dist: rich>=13.0
+Dynamic: license-file
+
+# mcr — Modal CUDA Runner
+
+Run a CUDA `.cu` file on an NVIDIA GPU from Modal, from anywhere on your machine, in one command. No local GPU required.
+
+## Install
+
+```
+pip install git+https://github.com/<your-handle>/modal-cuda-runner
+modal setup   # one-time Modal authentication
+```
+
+## Usage
+
+```
+$ mcr test.cu
+→ Running test.cu on T4
+  GPU: Tesla T4
+  Vector length: 1048576
+  Errors: 0
+  Sample: c[0]=3.0 c[1048575]=3.0
+✓ Finished executing on Modal (3.42s)
+```
+
+Pick a different GPU with `--gpu`:
+
+```
+mcr test.cu --gpu H100
+```
+
+Supported: `T4` (default), `L4`, `A10G`, `A100`, `A100-80GB`, `H100`.
+
+The CUDA program's stdout is forwarded to your stdout and its exit code becomes `mcr`'s exit code, so `mcr` composes cleanly with shell pipes and CI.
+
+## How it works
+
+`mcr` reads your `.cu` file locally and sends the **source as a function argument** to a Modal function running an `nvidia/cuda:12.9.0-devel-ubuntu22.04` image. Because the image never changes across invocations, Modal caches it forever — no per-run image rebuild.
+
+On the remote container: `nvcc` compiles the source, then the resulting binary runs on the requested GPU. stdout streams back as it's produced.
+
+- First run: slower — container cold start on Modal's side.
+- Subsequent runs: typically a few seconds for small kernels.
+
+## Not yet supported
+
+Intentionally scoped small for v1:
+- Multi-file projects / `.cuh` headers
+- Passing CLI args or stdin to the CUDA binary
+- Custom `nvcc` flags

modal_cuda_runner-0.1.0/modal_cuda_runner.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+mcr/__init__.py
+mcr/cli.py
+mcr/remote.py
+modal_cuda_runner.egg-info/PKG-INFO
+modal_cuda_runner.egg-info/SOURCES.txt
+modal_cuda_runner.egg-info/dependency_links.txt
+modal_cuda_runner.egg-info/entry_points.txt
+modal_cuda_runner.egg-info/requires.txt
+modal_cuda_runner.egg-info/top_level.txt

modal_cuda_runner-0.1.0/modal_cuda_runner.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

modal_cuda_runner-0.1.0/modal_cuda_runner.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mcr = mcr.cli:main

modal_cuda_runner-0.1.0/modal_cuda_runner.egg-info/requires.txt

@@ -0,0 +1,2 @@
+modal>=1.0
+rich>=13.0

modal_cuda_runner-0.1.0/modal_cuda_runner.egg-info/top_level.txt

@@ -0,0 +1 @@
+mcr

modal_cuda_runner-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "modal-cuda-runner"
+version = "0.1.0"
+description = "Run CUDA files on Modal from your local machine"
+readme = "README.md"
+license = "MIT"
+authors = [{name = "Corbin Platti", email = "csplatti@gmail.com"}]
+requires-python = ">=3.9"
+dependencies = ["modal>=1.0", "rich>=13.0"]
+keywords = ["cuda", "modal", "gpu", "nvcc", "cli"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Environment :: GPU :: NVIDIA CUDA",
+    "Topic :: Software Development :: Compilers",
+    "Topic :: System :: Distributed Computing",
+]
+
+[project.urls]
+Homepage = "https://github.com/csplatti/modal-cuda-runner"
+Repository = "https://github.com/csplatti/modal-cuda-runner"
+Issues = "https://github.com/csplatti/modal-cuda-runner/issues"
+
+[project.scripts]
+mcr = "mcr.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["mcr*"]

modal_cuda_runner-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+