Nvshmem Docs
NVIDIAOfficialCreated by NVIDIA NVSHMEM Team
- Skill
- Tool integration
- Documents and content
- Apache-2.0
- Medium risk
AutoGineer summary
Written by AutoGineer from the skill’s own files, not by the author
This skill provides a structured approach to querying official NVIDIA NVSHMEM and NVSHMEM4Py documentation. It uses a version-aware routing system to navigate between the latest documentation and historical archives for versions 3.0 and newer. The skill ensures technical accuracy by requiring live retrieval of official documentation pages rather than relying on internal knowledge, and it includes logic for verifying feature availability gates and compatibility between NVSHMEM and its Python bindings.
What it does
- Routes user queries to relevant official documentation sections using a topic map.
- Retrieves documentation for specific NVSHMEM versions via official archive URLs.
- Checks feature availability against introduced or removed version gates.
- Resolves compatibility information for NVSHMEM4Py and NVSHMEM version pairs.
- Provides direct links to official NVIDIA documentation and release notes.
- Handles version normalization and identifies when requested archives are unavailable.
When to use it
- When you need to find installation instructions or API references for a specific NVSHMEM version.
- When verifying if a specific feature was available in a particular release.
- When checking compatibility requirements between NVSHMEM and NVSHMEM4Py.
- When troubleshooting runtime settings or transport configurations using official documentation.
Advantages
- Ensures technical claims are backed by live, official documentation.
- Supports version-specific lookups to avoid confusion between different release cycles.
- Provides a consistent method for verifying feature gates and deprecations.
- Reduces manual search time by routing directly to the most relevant documentation pages.
Usage examples
- “Explain NVSHMEM_THREAD_SERIALIZED.”
- The agent retrieves the official documentation page for runtime settings and provides a summary of the environment variable's purpose and usage.
- “Find NVSHMEM4Py installation documentation for NVSHMEM 3.5.21.”
- The agent identifies the correct archive for NVSHMEM 3.5.x and provides the specific installation steps for the Python bindings.
- “Check whether NVSHMEM4Py 0.2.2 is compatible with NVSHMEM 3.6.5.”
- The agent consults the compatibility guide to verify the version pair and reports the support status.
Install
Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/nvidia/nvshmem-docs/downloadUnzip it into the cross-client skills folder of your project:
mkdir -p .agents/skills && unzip nvshmem-docs.zip -d .agents/skills
Documentation by NVIDIA NVSHMEM Team
NVSHMEM Documentation
Purpose
Find and summarize version-aware official NVSHMEM and NVSHMEM4Py documentation. Fetch and cite the most specific live pages; do not make technical claims from memory, search snippets, or the bundled topic map.
Prerequisites
Require topic-map.md and a retrieval tool that can open public NVIDIA HTTPS documentation. No API key or account is required. Support only NVSHMEM versions whose major version is 3 or later; reject a requested version below 3 before looking up documentation.
Instructions
Read the topic map for every request to resolve the topic and candidate pages. Use it only for routing; it is not evidence.
Choose the documentation edition
Normalize an optional leading v. Use latest when no version is requested. For an exact MAJOR.MINOR.PATCH version, first use its archive. Replace the literal VERSION in each archive URL below with the normalized NVSHMEM version (for example, 3.7.1 becomes https://archive.docs.nvidia.com/nvshmem/api/3.7.1/index.html):
| Content | Latest | Exact-version archive |
|---|---|---|
| API reference, concepts, usage, and runtime settings | https://docs.nvidia.com/nvshmem/api/latest/ | https://archive.docs.nvidia.com/nvshmem/api/VERSION/index.html |
| Release notes, installation, best practices, and support | https://docs.nvidia.com/nvshmem/release-notes-install-guide/ | https://archive.docs.nvidia.com/nvshmem/VERSION/index.html |
For a MAJOR.MINOR value, ask for the patch only when an exact archived edition is necessary. Start at the selected root and follow its table of contents because internal paths can differ between editions. For cross-cutting questions, use both documentation sets from the same edition.
When an exact archive is unavailable, inspect the relevant latest root and its official release/version information. If it identifies the requested version as the current release, use that latest documentation and state that the requested version is served from latest rather than an archive. If latest identifies a different version, report that the requested archive is unavailable; offer the different latest documentation only as clearly labeled current context. Never silently use latest documentation for another version.
Retrieve and answer
Infer the topic and optional version from the user or invoking skill, then route it with the topic map.
Open the appropriate root above and the relevant topic page in that edition. If an exact archive is unavailable, resolve whether
latestis the requested version before using it as evidence.Answer concisely with direct official links. State the documentation version when one was requested or applicability matters.
If an exact archive cannot be retrieved and latest is a different version, say so. Offer clearly labeled latest context only if useful.
Keep answers user-facing. Do not disclose internal retrieval mechanics or attempted-source details; report only conclusions, applicable versions, evidence links, and material uncertainty.
If live pages cannot be retrieved, return the appropriate root links, state that their contents were not verified, and avoid documentation-backed technical claims.
Handle NVSHMEM4Py
For an NVSHMEM4Py request with no version, use the latest documentation. If an NVSHMEM version is requested, use that NVSHMEM documentation edition without resolving the NVSHMEM4Py package version. Only when an NVSHMEM4Py version or version compatibility is requested, resolve the independent version pair from the live compatibility guide—never infer or hard-code it—and use the resolved NVSHMEM version to select an archive. Ask only when a bare version is ambiguous or multiple NVSHMEM releases match.
Unprefixed topic-map gates apply to NVSHMEM. Prefix a Python-only gate with nvshmem4py:, compare it only with the NVSHMEM4Py version, and name the version axis in the answer.
Check version gates
When a routed topic-map row has introduced_in or removed_in, verify the gate from its live official evidence and always report it. Compare NVSHMEM gates by MAJOR.MINOR and nvshmem4py: gates by the full package version. Report a mismatch when the requested version is before introduced_in or at/after removed_in; otherwise report no mismatch. Use a compact form such as Version gate: introduced in 3.7; requested 3.5 — mismatch.
Do not perform a broader availability search merely because a version was supplied. Only do so when the user explicitly asks whether an ungated feature or exact symbol is available, introduced, removed, or supported. Then inspect the requested archive and matching release notes. Absence from a page or search result is inconclusive; if evidence is not decisive, say availability could not be established.
For NVIDIA HPC SDK containers, use the official NGC catalog and HPC SDK documentation for container procedures. Do not infer the bundled NVSHMEM version from an image tag unless an official page states it.
Limitations
Documentation does not prove installed binaries, container contents, configuration, runtime behavior, or performance.
A missing page, symbol, or search result does not prove unavailability.
Technical answers require retrieved live official evidence; the topic map is only a routing index.
Troubleshooting
| Error | Cause | Solution |
|---|---|---|
| Topic-map route fails | Documentation moved | Navigate the selected edition's live table of contents. |
| Exact archive fails | The edition is unavailable, is the current unarchived release, or retrieval failed | Inspect latest to identify its version. Use it only when it matches the request; otherwise report the failure and offer it only as clearly labeled current context. |
| Requested NVSHMEM version is below 3.0 | Unsupported documentation edition | Reject the request; do not search archive or latest documentation. |
| Version is ambiguous | Component was not named | Ask whether it is an NVSHMEM or NVSHMEM4Py version. |
| Compatibility is unresolved | No unique live compatibility row exists | Report the candidates or uncertainty; do not infer a pair. |
Examples
Use $nvshmem-docs to explain NVSHMEM_THREAD_SERIALIZED.
Use $nvshmem-docs to find NVSHMEM4Py installation documentation for NVSHMEM 3.5.21.
Use $nvshmem-docs to check whether NVSHMEM4Py 0.2.2 is compatible with NVSHMEM 3.6.5.<!-- ci trigger -->
Files
- ATTRIBUTION.mdAdded by AutoGineer907 B
- BENCHMARK.md8.2 KiB
- LICENSELicence file added by AutoGineer11.2 KiB
- SKILL.md6.7 KiB
- evals/evals.json8.3 KiB
- references/topic-map.md22.2 KiB
- skill-card.md4.1 KiB
- skill.oms.sig4.7 KiB
references/topic-map.md
NVSHMEM Topic Map
Use this map for every NVSHMEM documentation request to route release, installation, application-use, best-practice, and API questions. Fetch selected pages before making technical claims.
introduced_inandremoved_inare optional feature-family gatesGates describe changes within the supported documentation range, currently NVSHMEM 3.0 and newer. Do not encode gates below that range.
Unprefixed
MAJOR.MINORvalues apply to NVSHMEM; prefix Python-only full-version gates withnvshmem4py:.A dash means that no boundary is asserted. Every populated gate must cite direct official release-note evidence.
For an NVSHMEM gate, a patch release is evidence for the feature family and is not part of the gate; preserve the full version for an NVSHMEM4Py gate.
Gates apply to the named feature family, not automatically to every identifying symbol; verify an exact symbol in the requested edition.
| Topic and identifying terms | Primary current page | Stable fallback | Inspect for | introduced_in | removed_in | Gate evidence |
|---|---|---|---|---|---|---|
| Documentation home, top-level navigation | NVSHMEM documentation | Same page | Installation, release-note, and best-practice entry points | — | — | — |
| Current release, features, compatibility, limitations, known issues | Release Notes | Documentation home | Current version-specific release note | — | — | — |
| Older release, introduction, deprecation, breaking change, fixed issue | Prior Releases | Older Prior Releases | Matching version notes and feature boundaries | — | — | — |
| Hardware, software, system, CUDA, compiler, network, launcher requirements | Installation Guide | Documentation home | Requirements and compatibility prerequisites | — | — | — |
| Download, package installation, archive, Ubuntu, APT, DEB, RHEL, RPM, YUM, DNF, tarball | Installation | Installation Guide | Package selection and installation procedures | — | — | — |
NVIDIA HPC SDK or NGC container, nvcr.io/nvidia/nvhpc, Docker, Apptainer, Singularity, development image, runtime image | NVIDIA HPC SDK NGC container | NVIDIA HPC SDK documentation | Current image tags, devel/runtime choice, container requirements, and links to the current container guide; do not infer the bundled NVSHMEM version from the tag | — | — | — |
| Build NVSHMEM itself, source build, CMake build variables, packages, dependency support | Installation | Installation Guide | Library build system and optional dependencies | — | — | — |
| GDAKI, IBGDA, GPUNetIO requirements, Mellanox, DMA-BUF, peer-memory, DOCA SDK | Installation Guide | Installation | Transport prerequisites and optional dependencies; apply the feature gates below before using current requirements for older releases | — | — | — |
Build with IBGDA or GPUNetIO, NVSHMEM_IBGDA_SUPPORT, NVSHMEM_GPUNETIO_SUPPORT | Installation | Installation Guide | Transport build options; apply the feature gates below before using current options for older releases | — | — | — |
Compile or link an NVSHMEM program, nvcc, -rdc, headers, host/device libraries | Compiling NVSHMEM Programs | Using NVSHMEM | Application compiler and linker commands, required libraries, and transport-specific link flags | — | — | — |
Build an application or library that uses NVSHMEM, CMake, find_package, shared library, symbol visibility | Building NVSHMEM Applications/Libraries | Using NVSHMEM | CMake integration, host/device library linkage, and library-composition constraints | — | — | — |
Run or launch an NVSHMEM program, mpirun, srun, nvshmrun, Hydra, PMI, PMIx | Running NVSHMEM Programs | Using NVSHMEM | Application launch procedures and process-manager selection | — | — | — |
| NVSHMEM4Py installation, Python, pip, wheel, conda | Installing NVSHMEM Language Bindings for Python | Installation Guide | Python requirements and installation methods; inspect compatibility only for a versioned request | — | — | — |
| Support, report a problem, security issue | Support | Documentation home | Official support and reporting paths | — | — | — |
| Introduction, features, transports, PGAS | Introduction | API guide | Conceptual overview | — | — | — |
| Examples of use, MPI/OpenSHMEM interoperability, communication model | Using NVSHMEM | API guide | General application usage | — | — | — |
| GPU-initiated NIC transport capability, current GDAKI terminology, historical GIC, CPU-proxy bypass | Using GPUDirect Async Kernel-Initiated Communication | Using NVSHMEM | GDAKI concepts and prerequisites | — | — | — |
IBRC remote transport, NVSHMEM_REMOTE_TRANSPORT=ibrc, InfiniBand or RoCE, native atomics, GDRCopy, NVSHMEM_DISABLE_IB_NATIVE_ATOMICS, NVSHMEM_DISABLE_GDRCOPY, NVSHMEM_IB_* | Environment Variables | Installation Guide | IBRC selection and IB/ROCE runtime settings | — | — | — |
IBDEVX remote transport, NVSHMEM_REMOTE_TRANSPORT=ibdevx, libmlx5 | Environment Variables | Compiling NVSHMEM Programs | IBDEVX selection and application link requirements | — | — | — |
IBGDA name and configuration, InfiniBand GPUDirect Async, NVSHMEM_IB_ENABLE_IBGDA, NVSHMEM_IBGDA_* | Environment Variables | Using GPUDirect Async Kernel-Initiated Communication | IBGDA runtime settings | — | — | — |
GPUNetIO remote transport and GDAKI mode, NVSHMEM_REMOTE_TRANSPORT=gpunetio, NVSHMEM_GPUNETIO_ENABLE_GDAKI, NVSHMEM_GPUNETIO_* | Environment Variables | Using GPUDirect Async Kernel-Initiated Communication | GPUNetIO transport selection and runtime settings | 3.7 | — | NVSHMEM 3.7.0 release notes |
Libfabric remote transport, NVSHMEM_REMOTE_TRANSPORT=libfabric, NVSHMEM_LIBFABRIC_PROVIDER, NVSHMEM_LIBFABRIC_*, EFA, CXI, verbs | Environment Variables | Installation Guide | Libfabric selection, provider, and runtime settings | — | — | — |
UCX remote transport, NVSHMEM_REMOTE_TRANSPORT=ucx, UCX_HOME, libucs, libucp | Environment Variables | Compiling NVSHMEM Programs | UCX selection and application link requirements | — | — | — |
| Best-practice overview | NVSHMEM Best Practices Guide | Documentation home | Best-practice topic selection | — | — | — |
| Initialization, bootstrap, MPI, OpenSHMEM, UID | NVSHMEM Initialization | Best Practices Guide | Initialization choices and guidance | — | — | — |
| Device, host, on-stream, thread, warp, block APIs | Device APIs | Best Practices Guide | API execution scopes and usage guidance | — | — | — |
| GDAKI device API behavior, IBGDA and GPUNetIO GDAKI, transport-aware RMA | Device APIs | Using NVSHMEM | GDAKI-specific device API guidance; apply transport gates before using it for older releases | — | — | — |
| CUDA stream, CUDA interoperability, circular dependency, ordering | CUDA NVSHMEM Interoperability | NVSHMEM and the CUDA Model | CUDA and NVSHMEM interaction guidance | — | — | — |
| Runtime configuration, symmetric heap, transport selection | NVSHMEM Runtime Configuration | Environment Variables | High-level runtime configuration guidance | — | — | — |
| Unsupported API, operation, transport restriction | NVSHMEM Unsupported Operations | Overview of the APIs | Unsupported and restricted behavior | — | — | — |
| Performance, coalescing, message size, quiet, synchronization cost | NVSHMEM Performance | Best Practices Guide | Performance practices and tradeoffs | — | — | — |
| IBGDA performance, QP type, DCI, RC, queue-pair tuning | NVSHMEM Performance | Environment Variables | IBGDA queue-pair tuning; apply the IBGDA gate before using current settings for older releases | — | — | — |
| CUDA execution, streams, circular dependencies, cooperative launch | NVSHMEM and the CUDA Model | API guide | CUDA execution semantics | — | — | — |
TMA, NVSHMEM_TMA_POLICY, nvshmemx_ask_smem, nvshmemx_give_smem, nvshmemx_release_smem | Using TMA with NVSHMEM | API guide | TMA use and constraints | 3.7 | — | NVSHMEM 3.7.0 release notes |
| Symmetric objects, operation ordering, atomicity, OpenSHMEM differences | Memory Model | API guide | Memory-model semantics | — | — | — |
| Progress, invocation, host/on-stream/device execution | Execution Model | API guide | Execution-model semantics | — | — | — |
| Constants, comparison operators, thread levels, team constants | Library Constants | API guide | Constant definitions | — | — | — |
| Handles, teams, initialization attributes, QP handles | Library Handles | API guide | Handle definitions | — | — | — |
Environment variables, bootstrap, collectives, transport, NVTX, NVSHMEM_* setting | Environment Variables | API guide | Runtime option names, types, and defaults | — | — | — |
| Supported APIs, unsupported OpenSHMEM APIs, CPU/GPU extensions, tile APIs | Overview of the APIs | API guide | API-family overview | — | — | — |
Initialize, finalize, query, UID, MPI communicator, nvshmem_init, nvshmemx_init_attr, thread support | Library Setup, Exit, and Query | API overview | Setup and teardown APIs | — | — | — |
Cooperative kernel launch, grid size, nvshmemx_collective_launch | Kernel Launch Routines | API overview | Kernel launch APIs | — | — | — |
| Symmetric allocation, malloc, calloc, free, align, buffer registration | Memory Management | API overview | Allocation and registration APIs | — | — | — |
QP-specific APIs, qpair, queue pair handle, nvshmemx_qp_*, nvshmemx_qp_handle_t, NVSHMEMX_QP_* | Queue Pair Specific APIs | API overview | QP creation, RMA, signaling, and ordering APIs | 3.5 | — | NVSHMEM 3.5.19 release notes |
Teams, split, translate PE, team creation/destruction, nvshmem_team_* | Team Management | API overview | Team APIs | — | — | — |
| Put, get, p, g, iput, iget, NBI, tile RMA | Remote Memory Access | API overview | RMA APIs | — | — | — |
| Atomic, fetch, set, compare-swap, swap, inc, add, and/or/xor | Atomic Memory Operations | API overview | Atomic APIs | — | — | — |
| Signal, put-with-signal, signal fetch, signal operator | Signaling Operations | API overview | Signaling APIs | — | — | — |
| Barrier, sync, all-to-all, broadcast, fcollect, reduction, tile collective | Collective Communication | API overview | Collective APIs | — | — | — |
| Wait, test, wait-until, signal-wait-until, point-to-point synchronization | Point-To-Point Synchronization | API overview | Synchronization APIs | — | — | — |
| Fence, quiet, flush, completion, visibility, source-buffer reuse | Memory Ordering | Memory Model | Ordering and completion APIs | — | — | — |
| NVSHMEM4Py, Python bindings, Python device API, Python interoperability | Language Bindings | API guide | Latest Python API documentation | — | — | — |
| NVSHMEM4Py package version, compatible NVSHMEM version, version pair, compatibility | NVSHMEM4Py Overview and Compatibility Guide | Language Bindings | Live NVSHMEM-to-NVSHMEM4Py compatibility table | — | — | — |
| Sample code, initialization, on-stream, threadgroup, ring, registration, Python examples | Examples | API guide | Example selection | — | — | — |
| FAQ, prerequisites, running, MPI/OpenSHMEM interoperability, GPU interconnect, debugging | Troubleshooting and FAQs | API guide | Troubleshooting guidance | — | — | — |
Exact-Symbol and Tool Routing
| Symbol or term pattern | Route to |
|---|---|
nvcc, -rdc, or libnvshmem_* in program compilation context | Compile or link an NVSHMEM program |
find_package, CMake application/library integration, or shared-library symbol visibility | Build an application or library that uses NVSHMEM |
mpirun, srun, nvshmrun, Hydra, PMI, or PMIx in application launch context | Run or launch an NVSHMEM program |
nvcr.io/nvidia/nvhpc, HPC SDK container, NGC container, Docker, Apptainer, or Singularity in installation context | NVIDIA HPC SDK or NGC container |
nvshmem_init*, nvshmem_finalize, nvshmem_global_exit, nvshmem*_info*, nvshmemx_*uniqueid* | Library Setup, Exit, and Query |
nvshmem_malloc, nvshmem_calloc, nvshmem_align, nvshmem_free, nvshmemx_buffer_* | Memory Management |
nvshmemx_qp_*, nvshmemx_qp_handle_t, or NVSHMEMX_QP_* | Queue Pair Specific APIs |
GDAKI, GPUDirect Async Kernel-Initiated, historical GIC, or GPU-initiated NIC communication | GDAKI overview; also inspect Device APIs and NVSHMEM Performance topics in this map |
IBRC, NVSHMEM_REMOTE_TRANSPORT=ibrc, NVSHMEM_DISABLE_IB_NATIVE_ATOMICS, NVSHMEM_DISABLE_GDRCOPY, or NVSHMEM_IB_* | IBRC remote transport; also inspect its installation requirements |
IBDEVX or NVSHMEM_REMOTE_TRANSPORT=ibdevx | IBDEVX remote transport; also inspect application link requirements |
IBGDA, NVSHMEM_IB_ENABLE_IBGDA, or NVSHMEM_IBGDA_* | IBGDA name and configuration; also inspect its requirements, build, and performance topics |
GPUNetIO, NVSHMEM_REMOTE_TRANSPORT=gpunetio, or NVSHMEM_GPUNETIO_* | GPUNetIO remote transport and GDAKI mode; also inspect its requirements and build topics |
libfabric, NVSHMEM_REMOTE_TRANSPORT=libfabric, or NVSHMEM_LIBFABRIC_* | Libfabric remote transport; also inspect its installation requirements |
UCX, NVSHMEM_REMOTE_TRANSPORT=ucx, UCX_HOME, libucs, or libucp | UCX remote transport; also inspect application link requirements |
nvshmem_team_*, nvshmemx_team_* | Team Management |
Put/get families, including p, g, strided, nonblocking, and tile variants | Remote Memory Access |
Names containing atomic | Atomic Memory Operations |
| Put-with-signal and signal update/fetch operations | Signaling Operations |
| Barrier, sync, all-to-all, broadcast, collect, and reduction operations | Collective Communication |
| Wait and test operations | Point-To-Point Synchronization |
| Fence, quiet, and flush operations | Memory Ordering |
NVSHMEM_* runtime setting | Environment Variables |
| NVSHMEM4Py or Python API without a version | Language Bindings; also inspect NVSHMEM4Py installation for package questions |
NVSHMEM4Py package version, nvshmem4py_version, or NVSHMEM/NVSHMEM4Py compatibility | NVSHMEM4Py Overview and Compatibility Guide |
Requirements and compatibility
Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta
“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.
Needs: Needs an API key
Security
What our scanner noticed· Medium risk
- Large base64-encoded blobs
A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.
Attribution and licence
- Created by
- NVIDIA NVSHMEM Team
- Publisher
- NVIDIA (Official)
- Source
- NVIDIA/skills · skills/nvshmem-docs · commit fce3cca
- Licence
- Apache License 2.0 (redistribution allowed)
- LICENSE (added by AutoGineer from LICENSE-APACHE)
- ATTRIBUTION.md (written by AutoGineer)
- Synced
AutoGineer is not affiliated with or endorsed by NVIDIA NVSHMEM Team or NVIDIA.
Download ZIP
The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download nvshmem-docs.zip