Generated banner for Nvshmem Docs
Generated logo for Nvshmem Docs

Nvshmem Docs

NVIDIAOfficialCreated by NVIDIA NVSHMEM Team

  • Skill
  • Tool integration
  • Documents and content
  • Apache-2.0
  • Medium risk

From the author

Find version-aware official NVSHMEM and NVSHMEM4Py documentation for releases, installation, APIs, runtime settings, transports, containers, and troubleshooting.
— the description by NVIDIA NVSHMEM Team

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

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/nvidia/nvshmem-docs/download
  2. Unzip 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):

ContentLatestExact-version archive
API reference, concepts, usage, and runtime settingshttps://docs.nvidia.com/nvshmem/api/latest/https://archive.docs.nvidia.com/nvshmem/api/VERSION/index.html
Release notes, installation, best practices, and supporthttps://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
  1. Infer the topic and optional version from the user or invoking skill, then route it with the topic map.

  2. Open the appropriate root above and the relevant topic page in that edition. If an exact archive is unavailable, resolve whether latest is the requested version before using it as evidence.

  3. Answer concisely with direct official links. State the documentation version when one was requested or applicability matters.

  4. 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

ErrorCauseSolution
Topic-map route failsDocumentation movedNavigate the selected edition's live table of contents.
Exact archive failsThe edition is unavailable, is the current unarchived release, or retrieval failedInspect 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.0Unsupported documentation editionReject the request; do not search archive or latest documentation.
Version is ambiguousComponent was not namedAsk whether it is an NVSHMEM or NVSHMEM4Py version.
Compatibility is unresolvedNo unique live compatibility row existsReport 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

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_in and removed_in are optional feature-family gates

  • Gates describe changes within the supported documentation range, currently NVSHMEM 3.0 and newer. Do not encode gates below that range.

  • Unprefixed MAJOR.MINOR values apply to NVSHMEM; prefix Python-only full-version gates with nvshmem4py:.

  • 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 termsPrimary current pageStable fallbackInspect forintroduced_inremoved_inGate evidence
Documentation home, top-level navigationNVSHMEM documentationSame pageInstallation, release-note, and best-practice entry points———
Current release, features, compatibility, limitations, known issuesRelease NotesDocumentation homeCurrent version-specific release note———
Older release, introduction, deprecation, breaking change, fixed issuePrior ReleasesOlder Prior ReleasesMatching version notes and feature boundaries———
Hardware, software, system, CUDA, compiler, network, launcher requirementsInstallation GuideDocumentation homeRequirements and compatibility prerequisites———
Download, package installation, archive, Ubuntu, APT, DEB, RHEL, RPM, YUM, DNF, tarballInstallationInstallation GuidePackage selection and installation procedures———
NVIDIA HPC SDK or NGC container, nvcr.io/nvidia/nvhpc, Docker, Apptainer, Singularity, development image, runtime imageNVIDIA HPC SDK NGC containerNVIDIA HPC SDK documentationCurrent 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 supportInstallationInstallation GuideLibrary build system and optional dependencies———
GDAKI, IBGDA, GPUNetIO requirements, Mellanox, DMA-BUF, peer-memory, DOCA SDKInstallation GuideInstallationTransport 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_SUPPORTInstallationInstallation GuideTransport 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 librariesCompiling NVSHMEM ProgramsUsing NVSHMEMApplication 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 visibilityBuilding NVSHMEM Applications/LibrariesUsing NVSHMEMCMake integration, host/device library linkage, and library-composition constraints———
Run or launch an NVSHMEM program, mpirun, srun, nvshmrun, Hydra, PMI, PMIxRunning NVSHMEM ProgramsUsing NVSHMEMApplication launch procedures and process-manager selection———
NVSHMEM4Py installation, Python, pip, wheel, condaInstalling NVSHMEM Language Bindings for PythonInstallation GuidePython requirements and installation methods; inspect compatibility only for a versioned request———
Support, report a problem, security issueSupportDocumentation homeOfficial support and reporting paths———
Introduction, features, transports, PGASIntroductionAPI guideConceptual overview———
Examples of use, MPI/OpenSHMEM interoperability, communication modelUsing NVSHMEMAPI guideGeneral application usage———
GPU-initiated NIC transport capability, current GDAKI terminology, historical GIC, CPU-proxy bypassUsing GPUDirect Async Kernel-Initiated CommunicationUsing NVSHMEMGDAKI 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 VariablesInstallation GuideIBRC selection and IB/ROCE runtime settings———
IBDEVX remote transport, NVSHMEM_REMOTE_TRANSPORT=ibdevx, libmlx5Environment VariablesCompiling NVSHMEM ProgramsIBDEVX selection and application link requirements———
IBGDA name and configuration, InfiniBand GPUDirect Async, NVSHMEM_IB_ENABLE_IBGDA, NVSHMEM_IBGDA_*Environment VariablesUsing GPUDirect Async Kernel-Initiated CommunicationIBGDA runtime settings———
GPUNetIO remote transport and GDAKI mode, NVSHMEM_REMOTE_TRANSPORT=gpunetio, NVSHMEM_GPUNETIO_ENABLE_GDAKI, NVSHMEM_GPUNETIO_*Environment VariablesUsing GPUDirect Async Kernel-Initiated CommunicationGPUNetIO transport selection and runtime settings3.7—NVSHMEM 3.7.0 release notes
Libfabric remote transport, NVSHMEM_REMOTE_TRANSPORT=libfabric, NVSHMEM_LIBFABRIC_PROVIDER, NVSHMEM_LIBFABRIC_*, EFA, CXI, verbsEnvironment VariablesInstallation GuideLibfabric selection, provider, and runtime settings———
UCX remote transport, NVSHMEM_REMOTE_TRANSPORT=ucx, UCX_HOME, libucs, libucpEnvironment VariablesCompiling NVSHMEM ProgramsUCX selection and application link requirements———
Best-practice overviewNVSHMEM Best Practices GuideDocumentation homeBest-practice topic selection———
Initialization, bootstrap, MPI, OpenSHMEM, UIDNVSHMEM InitializationBest Practices GuideInitialization choices and guidance———
Device, host, on-stream, thread, warp, block APIsDevice APIsBest Practices GuideAPI execution scopes and usage guidance———
GDAKI device API behavior, IBGDA and GPUNetIO GDAKI, transport-aware RMADevice APIsUsing NVSHMEMGDAKI-specific device API guidance; apply transport gates before using it for older releases———
CUDA stream, CUDA interoperability, circular dependency, orderingCUDA NVSHMEM InteroperabilityNVSHMEM and the CUDA ModelCUDA and NVSHMEM interaction guidance———
Runtime configuration, symmetric heap, transport selectionNVSHMEM Runtime ConfigurationEnvironment VariablesHigh-level runtime configuration guidance———
Unsupported API, operation, transport restrictionNVSHMEM Unsupported OperationsOverview of the APIsUnsupported and restricted behavior———
Performance, coalescing, message size, quiet, synchronization costNVSHMEM PerformanceBest Practices GuidePerformance practices and tradeoffs———
IBGDA performance, QP type, DCI, RC, queue-pair tuningNVSHMEM PerformanceEnvironment VariablesIBGDA queue-pair tuning; apply the IBGDA gate before using current settings for older releases———
CUDA execution, streams, circular dependencies, cooperative launchNVSHMEM and the CUDA ModelAPI guideCUDA execution semantics———
TMA, NVSHMEM_TMA_POLICY, nvshmemx_ask_smem, nvshmemx_give_smem, nvshmemx_release_smemUsing TMA with NVSHMEMAPI guideTMA use and constraints3.7—NVSHMEM 3.7.0 release notes
Symmetric objects, operation ordering, atomicity, OpenSHMEM differencesMemory ModelAPI guideMemory-model semantics———
Progress, invocation, host/on-stream/device executionExecution ModelAPI guideExecution-model semantics———
Constants, comparison operators, thread levels, team constantsLibrary ConstantsAPI guideConstant definitions———
Handles, teams, initialization attributes, QP handlesLibrary HandlesAPI guideHandle definitions———
Environment variables, bootstrap, collectives, transport, NVTX, NVSHMEM_* settingEnvironment VariablesAPI guideRuntime option names, types, and defaults———
Supported APIs, unsupported OpenSHMEM APIs, CPU/GPU extensions, tile APIsOverview of the APIsAPI guideAPI-family overview———
Initialize, finalize, query, UID, MPI communicator, nvshmem_init, nvshmemx_init_attr, thread supportLibrary Setup, Exit, and QueryAPI overviewSetup and teardown APIs———
Cooperative kernel launch, grid size, nvshmemx_collective_launchKernel Launch RoutinesAPI overviewKernel launch APIs———
Symmetric allocation, malloc, calloc, free, align, buffer registrationMemory ManagementAPI overviewAllocation and registration APIs———
QP-specific APIs, qpair, queue pair handle, nvshmemx_qp_*, nvshmemx_qp_handle_t, NVSHMEMX_QP_*Queue Pair Specific APIsAPI overviewQP creation, RMA, signaling, and ordering APIs3.5—NVSHMEM 3.5.19 release notes
Teams, split, translate PE, team creation/destruction, nvshmem_team_*Team ManagementAPI overviewTeam APIs———
Put, get, p, g, iput, iget, NBI, tile RMARemote Memory AccessAPI overviewRMA APIs———
Atomic, fetch, set, compare-swap, swap, inc, add, and/or/xorAtomic Memory OperationsAPI overviewAtomic APIs———
Signal, put-with-signal, signal fetch, signal operatorSignaling OperationsAPI overviewSignaling APIs———
Barrier, sync, all-to-all, broadcast, fcollect, reduction, tile collectiveCollective CommunicationAPI overviewCollective APIs———
Wait, test, wait-until, signal-wait-until, point-to-point synchronizationPoint-To-Point SynchronizationAPI overviewSynchronization APIs———
Fence, quiet, flush, completion, visibility, source-buffer reuseMemory OrderingMemory ModelOrdering and completion APIs———
NVSHMEM4Py, Python bindings, Python device API, Python interoperabilityLanguage BindingsAPI guideLatest Python API documentation———
NVSHMEM4Py package version, compatible NVSHMEM version, version pair, compatibilityNVSHMEM4Py Overview and Compatibility GuideLanguage BindingsLive NVSHMEM-to-NVSHMEM4Py compatibility table———
Sample code, initialization, on-stream, threadgroup, ring, registration, Python examplesExamplesAPI guideExample selection———
FAQ, prerequisites, running, MPI/OpenSHMEM interoperability, GPU interconnect, debuggingTroubleshooting and FAQsAPI guideTroubleshooting guidance———

Exact-Symbol and Tool Routing

Symbol or term patternRoute to
nvcc, -rdc, or libnvshmem_* in program compilation contextCompile or link an NVSHMEM program
find_package, CMake application/library integration, or shared-library symbol visibilityBuild an application or library that uses NVSHMEM
mpirun, srun, nvshmrun, Hydra, PMI, or PMIx in application launch contextRun or launch an NVSHMEM program
nvcr.io/nvidia/nvhpc, HPC SDK container, NGC container, Docker, Apptainer, or Singularity in installation contextNVIDIA 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 communicationGDAKI 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=ibdevxIBDEVX 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 libucpUCX remote transport; also inspect application link requirements
nvshmem_team_*, nvshmemx_team_*Team Management
Put/get families, including p, g, strided, nonblocking, and tile variantsRemote Memory Access
Names containing atomicAtomic Memory Operations
Put-with-signal and signal update/fetch operationsSignaling Operations
Barrier, sync, all-to-all, broadcast, collect, and reduction operationsCollective Communication
Wait and test operationsPoint-To-Point Synchronization
Fence, quiet, and flush operationsMemory Ordering
NVSHMEM_* runtime settingEnvironment Variables
NVSHMEM4Py or Python API without a versionLanguage Bindings; also inspect NVSHMEM4Py installation for package questions
NVSHMEM4Py package version, nvshmem4py_version, or NVSHMEM/NVSHMEM4Py compatibilityNVSHMEM4Py 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