Skip to content
Skills Library
DevOps & cloud · Building & coding

exec-local-compile

/exec-local-compile

Compile TensorRT-LLM on a compute node inside a Docker container. Use this when already on a compute node with GPUs visible.

Licence
MIT
Last repository change
27.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Compile TensorRT-LLM on a compute node inside a Docker container. Use this when already on a compute node with GPUs visible.

Original author description

Compile TensorRT-LLM on a compute node inside a Docker container. Use this when already on a compute node with GPUs visible.

How it works

  1. When to Use
  2. Prerequisites
  3. Instructions
  4. Build Flags
  5. Architecture Reference
  6. Incremental vs. Clean Builds
Original SKILL.md headings · 89 lines, 426 words
SKILL.md preview
---
name: exec-local-compile
description: Compile TensorRT-LLM on a compute node inside a Docker container. Use this when already on a compute node with GPUs visible.
license: Apache-2.0
metadata:
  author: NVIDIA Corporation
---

# Compile TensorRT-LLM (Local / Compute Node)

Compile TensorRT-LLM from source on a compute node inside a Docker container.

## When to Use

| Scenario | Use This Skill? |
|----------|----------------|
| On a compute node with GPUs visible (`nvidia-smi` works) | Yes |
| On a SLURM login node (no GPUs) | No — use `exec-slurm-compile` instead |

## Prerequisites

- You are inside a Docker/enroot container on a compute node
- `nvidia-smi` succeeds (GPUs visible)
- `/usr/local/tensorrt` exists (TensorRT installation in the container)

## Instructions

### Step 1: Verify Environment

Run `nvidia-smi` to confirm you are on a compute node with GPU access.

### Step 2: Locate the Codebase

`cd` to the TensorRT-LLM repository. If the path is not provided by the user, ask for it.

### Step 3: (Optional) Checkout Branch

If the user specifies a branch (e.g., "compile ToT"), checkout and pull:
```bash
git checkout main && git pull
```

### Step 4: Build

Run the build command (**incremental by default** — omit `-c`/`--clean` unless explicitly requested or the incremental build fails):

```bash
./scripts/build_wheel.py --use_ccache -a "<arch>" -f --nvtx
```

Replace `<arch>` with the target GPU architecture (see Architecture Reference below). If not specified by the user, auto-detect from `nvidia-smi`.

### Step 5: Install

```bash
pip install -e .[devel]
```

### Step 6: Verify

```bash
python3 -c "import tensorrt_llm; print(tensorrt_llm.__version__)"
```

## Build Flags

| Flag | Description |
|------|-------------|
| `-a "<arch>"` | Target GPU architecture(s) |
| `--nvtx` | Enable NVTX markers for profiling |
| `--use_ccache` | Use ccache for faster recompilation |
| `-f` / `--fast_build` | Skip some kernels for faster dev compilation. **Always use for dev builds.** |
| `-c` / `--clean` | Clean build directory before building. Only when needed (see below). |
| `--skip_building_wheel` | Build in-place without creating a wheel file |
| `--no-venv` | Skip virtual environment creation |

## Architecture Reference

| Value | GPU Family |
|-------|-----------|
| `"100-real"` | Blackwell (B200, GB200) |
| `"90-real"` | Hopper (H100, H200) |
| `"89-real"` | Ada Lovelace (L40S) |
| `"80-real"` | Ampere (A100) |
| `"90;100-real"` | Multiple architectures |

## Incremental vs. Clean Builds

**Default to incremental builds** — CMake only recompiles changed files, saving significant time.

Use a **clean build** (`-c`) only when:
- The user explicitly requests a clean/fresh build
- An incremental build fails with linker errors, stale object files, or CMake cache issues
- Major branch changes (e.g., rebasing across many commits) that may invalidate the build cache
- Build system files changed (`CMakeLists.txt`, `*.cmake`)

Versions

The database has no other skills named exec-local-compile.

Database snapshot: 13.11.2026 · package version ade1484c2650 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100nvidia-tensorrt-llm-exec-local-compile
    Compile TensorRT-LLM on a compute node inside a Docker container. Use this when already on a compute node with GPUs visible.
  • 100nvidia-tensorrt-llm-exec-slurm-compile
    Compile TensorRT-LLM on a SLURM cluster. Covers submitting a batch job with a container image, monitoring the job, and verifying the build. Use when the user wants to compile TRT-LLM remotely via SLURM rather than on a local compute node.
  • 100exec-slurm-compile
    Compile TensorRT-LLM on a SLURM cluster. Covers submitting a batch job with a container image, monitoring the job, and verifying the build. Use when the user wants to compile TRT-LLM remotely via SLURM rather than on a local compute node.
  • 100exec-slurm-compile
    Compile TensorRT-LLM on a SLURM cluster. Covers submitting a batch job with a container image, monitoring the job, and verifying the build. Use when the user wants to compile TRT-LLM remotely via SLURM rather than on a local compute node.
  • 95tensorrt-llm
    Optimizes LLM inference with NVIDIA TensorRT for maximum throughput and lowest latency. Use for production deployment on NVIDIA GPUs (A100/H100), when you need 10-100x faster inference than PyTorch, or for serving models with quantization (FP8/INT4), in-flight batching, and multi-GPU scaling.
  • 100tao-run-on-docker
    The Docker execution platform for TAO jobs — a local daemon or a remote GPU box via DOCKER_HOST=ssh://user@host. Implements the four-verb consumer contract (submit/status/logs/cancel) over the docker CLI, wired to the job-record, tao-data-io staging, and the redact lint, on top…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.