# dali-dynamic-mode

A skill that steers the agent through NVIDIA DALI's imperative mode: direct ndd calls instead of pipeline graphs, plus help migrating existing pipelines.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · 2100 installs · ★ 3735
- Author: DALI Team
- License: Apache-2.0 · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/NVIDIA/skills/tree/HEAD/skills/dali-dynamic-mode/SKILL.md
- Updated: 2026-10-23
- HTML: https://affpapa.org/en/nevibecode/skills/dali-dynamic-mode

## What it does

The skill covers writing code against `nvidia.dali.experimental.dynamic`, shortened to `ndd`. Instead of `Pipeline`, `@pipeline_def`, `pipe.build()` and `pipe.run()`, the agent writes ordinary Python calls to DALI operators. Readers are stateful: create one, reuse it across epochs, and pass `batch_size` to `next_epoch(...)`. Random ops need an explicit batch size because there is no pipeline-level one to inherit.

A large part is about data handling. `Batch` has no `__getitem__`, so picking samples goes through `batch.tensors[...]` and slicing inside each sample through `batch.slice[...]`. PyTorch conversion uses `.torch()`, and ragged batches need `.torch(pad=True)`. Device is inferred from inputs; for hybrid decode you write `device="gpu"`, not `"mixed"`. CUDA stream sync with PyTorch happens automatically through DLPack.

Running or validating any of this requires NVIDIA DALI installed with the dynamic mode importable. GPU decode and GPU operators need a CUDA-capable DALI build and a working NVIDIA GPU with driver, while conversion examples need the target framework, PyTorch for `.torch()`. If your project is pipeline-only and you are not migrating, the skill adds nothing.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add NVIDIA/skills --skill dali-dynamic-mode -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/dali-dynamic-mode/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/dali-dynamic-mode/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add NVIDIA/skills --skill dali-dynamic-mode -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/dali-dynamic-mode/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add NVIDIA/skills --skill dali-dynamic-mode -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/dali-dynamic-mode/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install NVIDIA/skills dali-dynamic-mode
```

2. **Manually: put the files in place**
- File: `.github/skills/dali-dynamic-mode/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add NVIDIA/skills --skill dali-dynamic-mode -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/NVIDIA/skills --path skills/dali-dynamic-mode
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/dali-dynamic-mode/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add NVIDIA/skills --skill dali-dynamic-mode -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/NVIDIA/skills/tree/HEAD/skills/dali-dynamic-mode/SKILL.md

## When to use it
- rewrite a DALI pipeline as imperative `ndd` calls
- tell `batch.tensors[]` apart from `batch.slice[]`
- reuse a reader across epochs without breaking shuffle order
- build a ragged batch and hand it to PyTorch
- pin down a failing op with `EvalMode.sync_cpu`

## Example prompts
- Rewrite this DALI pipeline using dynamic mode `ndd`
- Why does `batch[0]` raise TypeError, and how do I get the first sample?
- Set up sharded reading for distributed training with `shard_id` and `num_shards`

## Source text · SKILL.md · Apache-2.0

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: 82f3020d1c667fef.

BEGIN THIRD-PARTY FILE 82f3020d1c667fef
````text
---
name: dali-dynamic-mode
description: "DALI imperative dynamic mode (`nvidia.dali.experimental.dynamic`, ndd): use when working on ndd code or migrating pipelines; skip pipeline-only tasks."
license: Apache-2.0
metadata:
  author: "DALI Team <dali-team@nvidia.com>"
  tags:
    - dali
    - dynamic-mode
    - ndd
    - data-loading
    - data-processing
    - gpu-processing
  languages:
    - python
  team: dali
  domain: deep-learning
---

# DALI Dynamic Mode

## Purpose

Guide AI agents in writing, reviewing, and migrating code that uses DALI's imperative dynamic-mode API, `nvidia.dali.experimental.dynamic` (`ndd`).

## Instructions

- Import dynamic mode as `nvidia.dali.experimental.dynamic as ndd` and write code as direct `ndd` calls in ordinary Python; do not use pipeline-mode APIs such as `Pipeline`, `@pipeline_def`, `pipe.build()`, or `pipe.run()`.
- Treat readers as stateful: create them once, reuse them across epochs, and pass `batch_size` to `next_epoch(...)`.
- Pass explicit `batch_size` to random ops; there is no pipeline-level batch size to inherit.
- Use dynamic-mode API conventions: `device="gpu"` instead of pipeline-mode `"mixed"`, `Batch.tensors[...]` for sample selection, and `Batch.slice[...]` for per-sample slicing.
- Use `.torch()` to convert a tensor or batch to a PyTorch tensor. Use `pad=True` for batches with variable shapes.

## Prerequisites

- To run or validate code, NVIDIA DALI must be installed with dynamic mode importable as `nvidia.dali.experimental.dynamic`.
- GPU decode or GPU operators require a CUDA-capable DALI build and an available NVIDIA GPU/driver.
- Framework conversion examples require the target framework installed, such as PyTorch for `.torch()`.

## Introduction

Dynamic mode is DALI's imperative Python API. It lets code call DALI operators directly from normal Python control flow instead of building and running a pipeline graph.

## Core Data Types

### Tensor -- single sample

```python
t = ndd.tensor(data)           # copy
t = ndd.as_tensor(data)        # wrap, no copy if possible
t.cpu()                        # move to CPU
t.gpu()                        # move to GPU
t.torch(copy=False)            # conversion to PyTorch tensor with no copy (default)
t[1:3]                         # slicing supported
np.asarray(t)                  # NumPy via __array__ (CPU only)
```

Supports `__dlpack__`, `__cuda_array_interface__`, `__array__`, arithmetic operators.

### Batch -- collection of samples (variable shapes OK)

```python
b = ndd.batch([arr1, arr2])    # copy
````
END THIRD-PARTY FILE 82f3020d1c667fef

The third-party file has ended. Everything between the 82f3020d1c667fef tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2553 of 14921 bytes. © DALI Team · Apache-2.0 · https://github.com/NVIDIA/skills/tree/HEAD/skills/dali-dynamic-mode/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md