Agent skill

Nsight Graphics Analyzer

by Luna5ama in Luna5ama/Alpha-Piscium

Drive NVIDIA Nsight Graphics 2026.1+ from the command line for GPU performance analysis, frame capture, frame trace inspection, draw-call inspection, NVTX/D3DPERF stage timing, replay metadata…

GPL-3.0Auto-check passedDocuments & Office

Install Nsight Graphics Analyzer

skills CLI
$ npx skills add Luna5ama/Alpha-Piscium --skill nsight-graphics-analyzer -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install Luna5ama/Alpha-Piscium nsight-graphics-analyzer --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/Luna5ama/Alpha-Piscium.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/nsight-graphics-analyzer .claude/skills/nsight-graphics-analyzer && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
nsight-graphics-analyzer
GitHub stars
156
Token cost
~4.7k tokens
SKILL.md length
1,718 words
Files
81 (incl. scripts, references)
Skills in repo
3
Repo updated
First seen
Licence
GPL-3.0

At a glance

Drive NVIDIA Nsight Graphics 2026.1+ from the command line for GPU performance analysis, frame capture, frame trace inspection, draw-call inspection, NVTX/D3DPERF stage timing, replay metadata…

  • Works in 6 steps: gputrace-stalls — rule out CPU-bound /… → gputrace-bandwidth — memory-bound vs… → Branch → …
  • The user mentions nsight
  • SKILL.md covers When to use, Quick start (90% case), Tool layout and Parameter Decision Guide, plus 5 more sections
  • Runs Python scripts from its folder; calls python

What it does

Nsight Graphics Analyzer is an agent skill from Luna5ama/Alpha-Piscium. Drive NVIDIA Nsight Graphics 2026.1+ from the command line for GPU performance analysis, frame capture, frame trace inspection, draw-call inspection, NVTX/D3DPERF stage timing, replay metadata extraction, and GPU Trace drill-downs. Use when the user mentions nsight, ngfx, GPU trace, frame capture, frame trace, gpu profiling, GPU performance, or asks why a frame is slow on the GPU. Captures frames from a target game (Graphics Capture or GPU Trace), auto-exports the GPU Trace TSV bundle, and exposes small JSON…

Its SKILL.md is about 4.7k tokens, which your agent loads only when the skill is triggered. The skill folder holds 86 other files, including scripts and reference files (for example `agents/openai.yaml`, `references/parameters.md` and `scripts/nsight.py`).

It sits in Documents & Office, covering CSV and tabular files. It works with NVIDIA AI Platform, C++ and Python. The repository describes itself as: High-quality realistic Minecraft shaderpack. The licence is GPL-3.0.

When your agent uses it

  • The user mentions nsight
  • GPU performance
  • Asks why a frame is slow on the GPU

Example prompts

  • “/nsight-graphics-analyzer”

Requirements

  • Python 3

Workflow steps

6 steps, taken from the first numbered list in SKILL.md.

  1. gputrace-stalls — rule out CPU-bound / pipeline-bubble first; if
  2. gputrace-bandwidth — memory-bound vs compute-bound axis.
  3. Branch
  4. gputrace-overdraw — opaque-pass quality.
  5. gputrace-geometry — vertex/primitive frontend.
  6. gputrace-draws — CPU-side state-churn / small-batch signals.

What it can do on your machine

Read from SKILL.md and the folder at commit f2401e9. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 12 files in scripts/ (Python, from the files we listed), which the agent can run.

    Shell commands in SKILL.md call:

    • python

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Nsight Graphics Analyzer loads about 4.7k tokens when it runs, and up to ~7k if it reads all its reference files. Until then it costs about 158 tokens; SKILL.md has 1,718 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~158
When it runs · the whole SKILL.md, loaded when a task matches
~4.7k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~7k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from Luna5ama/Alpha-Piscium at commit f2401e9, republished under its GPL-3.0 licence (© Luna5ama). 1,718 words, ~4,696 tokens.

Download SKILL.mdSave it as .claude/skills/nsight-graphics-analyzer/SKILL.md (or your agent's skills folder). This skill also uses 80 other files; get the full folder from GitHub.
name
nsight-graphics-analyzer
description
Drive NVIDIA Nsight Graphics 2026.1+ from the command line for GPU performance analysis, frame capture, frame trace inspection, draw-call inspection, NVTX/D3DPERF stage timing, replay metadata extraction, and GPU Trace drill-downs. Use when the user mentions nsight, ngfx, GPU trace, frame capture, frame trace, gpu profiling, GPU performance, or asks why a frame is slow on the GPU. Captures frames from a target game (Graphics Capture or GPU Trace), auto-exports the GPU Trace TSV bundle, and exposes small JSON queries the agent can read cheaply. Wraps `ngfx.exe`, `ngfx-capture.exe`, `ngfx-replay.exe`.
metadata.version
0.1.0
metadata.short-description
Capture and analyze Nsight GPU traces.
metadata.when_to_use
GPU performance analysis, frame capture, draw-call inspection, NVTX-marked stage timing, or replay-time metadata extraction. Trigger phrases: nsight, ngfx…
metadata.requires
Windows 10/11, NVIDIA Nsight Graphics 2026.1 or newer, Python 3.10+
metadata.categories
graphics, gpu, profiling, debugging

Nsight Graphics 2026 Skill

Wrapper around NVIDIA Nsight Graphics 2026.1+. The agent captures GPU frames, gets 3 small JSON artifacts, and uses drill-down subcommands to answer follow-up questions without ever loading the raw 300+ MB TSV bundle.

When to use

User intents that should trigger this skill:

  • "Why is this frame slow on the GPU?" / "Profile GPU performance" / "Grab a frame to inspect"
  • "Capture a frame from this game" / "frame trace" / "GPU Trace"
  • "What draw calls does this frame make?" / "API stream"
  • "How fast does this .ngfx-capture replay?" / "replay perf"
  • "Inspect markers / stages / metrics in this .ngfx-gputrace"
  • "Generate a C++ capture so I can edit and replay it"

Trigger keywords: nsight, ngfx, nsight graphics, GPU trace, frame capture, frame trace, gpu profiling, frame profiling.

Quick start (90% case)

# 1. capture a 200 ms GPU Trace 30 s after launch (game must already be loaded)
python "<SKILL_DIR>/scripts/nsight.py" gputrace-capture \
  --exe "C:\Game\game.exe" --wd "C:\Game" \
  --start-after-ms 30000 --max-duration-ms 200 \
  --architecture Ada --metric-set-name "Throughput Metrics" \
  --time-every-action \
  --out "D:\captures\game.ngfx-gputrace"

# 2. the wrapper writes 3 small JSON next to the .ngfx-gputrace:
#    <session>/game.gputrace.summary.json  (~50 KB)
#    <session>/game.gputrace.stages.json   (~3  KB)
#    <session>/game.gputrace.actions.json  (~15 KB)

# 3. drill into the dominant stage from summary.json's analysis.hotspots
python "<SKILL_DIR>/scripts/nsight.py" gputrace-stages \
  "<session>/game.ngfx-gputrace" --parent "Render Camera" --top 10

Replace <SKILL_DIR> with the directory containing this SKILL.md. For any subcommand's full flag list run python scripts/nsight.py <cmd> --help.

Three rules to never break:

  • GPUTRACE_REGIMES.xls is 300+ MB — never Read it directly. Drill through gputrace-stages / gputrace-actions / gputrace-metric.
  • Anti-cheat games (EAC/BattlEye/Vanguard) refuse capture and exit with code 4. Try cpp-capture or disable the anti-cheat per game policy.
  • If a capture fails with a permission error, re-run from an elevated PowerShell. doctor reports is_admin.

Tool layout

A single Python entry point dispatches to 25 subcommands. Full flag list for any subcommand: python "<SKILL_DIR>/scripts/nsight.py" <cmd> --help.

GroupSubcommandsPurpose
Envlocate / doctor / capabilities / killDetect install, self-check, dump per-binary flags, kill residuals
Run no-capturelaunch / attachRun game under ngfx with no capture taken
Capturecapture / cpp-capture / gputrace-captureGraphics Capture / C++ Capture / GPU Trace + 3 JSON
Triggertrigger-hotkeySynthesize F11 (or another F-key) into a target window so the agent — not a human — fires a --start-after-hotkey capture
Post-processgputraceRebuild 3 JSON from existing trace
Drillgputrace-stages / gputrace-actions / gputrace-metricStage tree / leaf-marker top-N / metric aggregate
Diagnose (7)gputrace-{stalls,bandwidth,shader-bound,texture-cache,overdraw,geometry,draws}Focused verdict[]-producing diagnostic commands
Replayexport-{metadata,functions,screenshot} / replay-perf / replay-analyzeMetadata / API stream / PNG extraction; replay timing; combined

Exit codes: 0 success, 2 user error, 3 Nsight not found, 4 underlying tool failed, 5 wrapper-side timeout. stdout is JSON for query commands; pass --out FILE to redirect.

Parameter Decision Guide

For decisions beyond the Quick Start path — picking a start trigger, tuning trace quality vs cost, navigating drill-down after capture, or reaching for an advanced ngfx flag — Read references/parameters.md. That file contains five decision tables:

  • A. User goal → command → required flags → what to read
  • B. GPU Trace start trigger choice (--start-after-ms vs --start-after-frames vs --start-after-hotkey vs SDK)
  • C. Trace quality vs cost trade-off (--time-every-action, --set-gpu-clocks, --real-time-shader-profiler, etc.)
  • D. Drill-down workflow once the three JSON artifacts are written
  • E. Advanced 1:1 ngfx flags (rare; skip unless asked)

⚠️ One red-line warning that belongs in the body, not the reference: --multi-pass-metrics is unusable through this wrapper (Nsight 2025.3 + 2026.1, verified May 2026). Combined with the mandatory --auto-export it deterministically writes an unloadable .ngfx-gputrace. The wrapper still accepts the flag for forensic / bug-report purposes but emits a runtime WARNING and returns bundle_complete=False. Full investigation in DESIGN.md → Investigations.

Capabilities-driven feature gating

The wrapper checks every conditional flag against the live ngfx install and exits with code 4 + a clear message if your build lacks that flag — preventing cryptic ngfx parse errors. Run python scripts/nsight.py capabilities to see what's available locally; wrapper_features.<key> maps each wrapper flag to its underlying ngfx flag.

Subcommand reference

Full flag list for any subcommand: python scripts/nsight.py <cmd> --help. This section is the agent-facing purpose only; flag detail lives in --help.

gputrace-capture

Wraps ngfx.exe --activity "GPU Trace Profiler" --auto-export .... Always writes <session>/<file>.ngfx-gputrace + BASE/ + 3 JSON artifacts. Use --dry-run to preview the ngfx command line.

trigger-hotkey

Synthesize a function-key press (default F11) into a target window via Win32 SendInput. Pair with gputrace-capture --start-after-hotkey run in the background to let the agent — not a human — fire the trigger once an external workflow has reached the desired scene. See the Agent-triggered capture workflow pattern below.

gputrace

Re-runs the parser pipeline against an existing trace + BASE/. Use after a skill upgrade to regenerate JSON without re-launching the game.

gputrace-stages

Stage-tree drill. --parent REGEX returns children of all matching parents grouped by name. --depth N restricts to a specific depth.

gputrace-actions

Top-N leaf markers (deepest D3DPERF_EVENTS nodes). --filter matches the leaf's own name; --in-marker matches any ancestor in the path. --with-metrics adds the headline block via one streaming REGIMES pass (~1-2 s). Important: read the definition field — actions are leaf markers, not raw draw calls.

gputrace-metric

Aggregate one metric. --name PATTERN is a regex over the metric catalog; --all-matches allows multi-match output. --in-marker REGEX returns per-marker windows in addition to the global aggregate.

Diagnostic command family (7 commands)

gputrace-stalls, gputrace-bandwidth, gputrace-shader-bound, gputrace-overdraw, gputrace-geometry, gputrace-texture-cache, gputrace-draws — focused diagnostic commands. Each returns a verdict[] array of {tag, severity, message}, severity ∈ {info, medium, high}. Thresholds are heuristics; treat verdicts as investigation starters, not absolute judgments. Most accept --in-marker REGEX to scope to a subtree (gputrace-stalls and gputrace-draws are whole-frame only).

Recommended investigation order on an unknown frame:

  1. gputrace-stalls — rule out CPU-bound / pipeline-bubble first; if the GPU isn't busy, the rest of the analysis doesn't matter.
  2. gputrace-bandwidth — memory-bound vs compute-bound axis.
  3. Branch:
    • memory-bound → gputrace-texture-cache to localize
    • compute-bound → gputrace-shader-bound for SM utilization detail
  4. gputrace-overdraw — opaque-pass quality.
  5. gputrace-geometry — vertex/primitive frontend.
  6. gputrace-draws — CPU-side state-churn / small-batch signals.
replay-perf

Replays a .ngfx-capture N times via ngfx-replay -n N --perf-report-dir and parses iteration_times.csv. Useful for replay-cost regression; not for original-app GPU performance (that's gputrace-capture).

How to read the artifacts

Show full SKILL.md (819 more words)Show less
Vibris/glc2vk replayer override

When the traced executable is the Vibris OpenGL or Vulkan replayer, ignore all whole-capture and relative-to-capture performance values. This includes capture duration, analysis.frame_budget, fraction_of_gpu, replayer CPU submission, replay-perf, Copy work, and sleep/yield time. They measure replayer and OS behavior, not Iris shader performance.

Use only individual pass durations inside the complete outer Replay marker, or pass_duration / Replay_duration. Prefer gputrace-actions --in-marker "^Replay$" to select passes and use the stage tree for the exact outer Replay duration. Exclude the outer Copy marker and the unmarked tail sentinel dispatch from shader comparisons.

The rules below describe ordinary application captures; this replayer override takes precedence.

Read summary.json first. Four fields that matter:

  • analysis.frame_budget.verdict → 60fps / 30fps / below_30fps
  • analysis.throughput.dominant → most loaded subsystem
  • analysis.hotspots.slowest_stage → where to drill
  • analysis.warnings → natural-language flags

Then pick a drill direction: stage > 50% GPU → drill it; throughput dominated by dram/pcie → memory-heavy; sm dominant → shaders. Always drill via subcommands, never by reading BASE/*.xls directly (REGIMES is 300+ MB).

Top-level JSON shapes:

summary.json:  source, session, summary{frame/marker/metric counts},
               analysis{frame_budget, throughput, hotspots, warnings},
               headline_metrics, metrics[], hardware_context
stages.json:   source, headline_metrics, roots[], top_stages[]
               each: name, depth, total_duration_ns, fraction_of_gpu, headline
actions.json:  source, definition, top_20_slowest_actions[]
               each: name, path, instance_count, duration fields, headline

Diagnostic verdict thresholds — use these to interpret verdict[] beyond just severity:

CommandKey signalHealthyRed
overdrawoverdraw_ratio~1.0 (1.5-3 typical)> 3
overdrawzcull_rejection_rate> 0.3< 0.3 (ZCull defeated)
overdrawlate_z_attrition_rate< 0.3high (PS work thrown away)
bandwidthper-tier % of peak< 60%≥ 80% saturated (60-80% pressure)
bandwidthdominant tier vs SMbalancedtier ≥ SM by 15pp → memory-bound
bandwidthPCIe sustained< 30%≥ 30% (host↔device thrash)
shader-boundsm_stall_ratiolowhigh (memory latency / dep chains)
shader-boundasync-compute usebalancedcompute ≥ 30% but < 10% async (underused)
geometrypixels_per_prim≥ 16< 4 (micro-triangles)
texture-cachel1tex__t_sector_hit_rate.pct≥ 70%< 50% (thrashing)
texture-cachemiss_to_dramlow≥ 10% (DRAM burned on misses)
stallsgr_idle_pctlowhigh (GPU not fed)
stallsmarker_coverage_pcthighlow (idle BETWEEN markers → CPU bound / waits)
drawssmall_leaf_pct (< 5 μs)lowhigh (batching candidates)

Workflow patterns

First-pass perf analysis

gputrace-capture → read summary.json → 1-2 drill rounds → write Markdown report. Stop drilling once the bottleneck is at the engine-marker level (e.g. "GPUDriven.RenderMesh(Bush)") or attributable to a metric pattern (e.g. dram throughput > 80%).

Deep bottleneck dive (single stage > 80% of frame time)
gputrace-stages --parent "<stage>" --top 20
gputrace-actions --in-marker "<stage>" --top 20 --with-metrics
gputrace-metric --name "dramc__throughput" --in-marker "<stage>"
gputrace-metric --name "sm__throughput" --in-marker "<stage>"
Capture-once-then-iterate
gputrace-capture --exe ... --out trace.ngfx-gputrace
# now drill repeatedly; no re-launch needed
gputrace-stages "<session>/trace.ngfx-gputrace" ...
gputrace-actions "<session>/trace.ngfx-gputrace" ...
Reanalyze an old trace
gputrace "<session>/old-trace.ngfx-gputrace"   # rebuilds 3 JSON
cpp-capture for repro (deterministic C++ replay code)
cpp-capture --exe ... --wait-seconds 10 --out D:\repro
Attach to a running game (can't relaunch, e.g. multiplayer)
attach --activity "GPU Trace Profiler" --pid 12345
# user presses F11 in the running app
Agent-triggered capture in a larger workflow

Use this when: the agent is orchestrating a wider workflow — launching the game, running automated tests / bot actions / other skills, then deciding when to capture — and only the agent (not a human at the keyboard) knows when the target scene is on screen. Timer-based triggers (--start-after-ms / --start-after-frames) don't fit because the runtime of the surrounding workflow is unpredictable.

Why F11 simulation is the only option: ngfx's GPU Trace activity exposes exactly five start triggers (--start-after-ms / --start-after-frames / --start-after-submits / --start-after-hotkey / --start-with-ngfx-sdk / --start-on-replay-begin). ngfx-rpc.exe is the UI↔replayer IPC, not a trace-trigger RPC, and --start-with-ngfx-sdk requires the game to link the NGFX SDK and call NGFX_GPUTrace_StartTrace. For an unmodified target, hotkey is the only externally addressable trigger, and trigger-hotkey synthesizes it without a human.

Pattern:

# 1. Launch ngfx + game in the background, armed for F11 trigger.
#    DO NOT wait on this command — it blocks until the trace is written.
python scripts/nsight.py gputrace-capture \
  --exe "C:\Game\game.exe" --wd "C:\Game" \
  --start-after-hotkey \
  --max-duration-ms 200 \
  --architecture <arch> --metric-set-name "Throughput Metrics" \
  --time-every-action \
  --out "D:\captures\game.ngfx-gputrace"
# (Run via your harness's background-task primitive; capture the task ID.)

# 2. Attach a streaming watcher to the background task's output so the
#    agent is notified when the bundle is written. The wrapper prints
#    "GPU Trace report saved to ..." then "bundle_complete=True". Watch
#    for those lines (and also for "error", "fatal", "denied" to fail fast).

# 3. The agent now runs the rest of the workflow (other skills, automated
#    tests, scripted gameplay) — no polling. The capture is dormant in
#    the game process; F11 has not been pressed yet.

# 4. When the workflow signals "ready to capture":
python scripts/nsight.py trigger-hotkey --process game
# Returns JSON with foreground_ok / sent fields. exit 0 = key delivered.

# 5. ngfx hook receives F11, runs the 200 ms trace, writes the bundle,
#    wrapper post-processes into 3 JSON. The streaming watcher from step 2
#    fires; the agent reads summary.json and drills as usual.

Notes:

  • Background launch is mandatory. gputrace-capture blocks until the bundle is written, which is "forever" from the agent's point of view (it depends on when step 4 fires). The agent must run step 1 asynchronously.
  • Watch for completion, do not poll. The wrapper writes bundle_complete=True
    • the saved path to its stdout/stderr; pipe that into your harness's streaming notification primitive so the agent reacts to the event rather than guessing.
  • Windowed/borderless mode preferred. SendInput is reliable against windowed and borderless-window games. Exclusive-fullscreen + DRM combinations can swallow synthetic keystrokes; if trigger-hotkey reports sent=true but no trace appears, switch the game to borderless-window and retry.
  • Foreground stealing is restricted on Windows. trigger-hotkey calls AllowSetForegroundWindow(ASFW_ANY) + SetForegroundWindow, which works from an elevated shell (doctor reports is_admin=true) and usually from a non-elevated shell that recently saw user input. If it can't bring the window forward it still sends the key (ngfx's hook is global) and emits a stderr WARNING. Pass --no-foreground to skip the foreground step entirely if you'd rather not steal focus.
  • Use --use-scancode if the default fails. Some engines / DRM shims only honour hardware scancodes (KEYEVENTF_SCANCODE). The flag toggles the wParam encoding without other changes.
  • ngfx 2026.1.x cleanup-phase crash is benign. After the trace is written, ngfx exits with rc 0xC0000409 after trace_written=True and bundle_complete=True. The wrapper detects this and still produces the 3 JSON. Don't treat the non-zero rc as failure; check bundle_complete instead.
  • Disambiguating multiple instances. If tasklist finds more than one process matching --process, trigger-hotkey refuses and lists the PIDs; re-run with --pid <N>. Always use --pid when ngfx itself launched the game (you have the PID from the capture-task output).

Out of scope

  • Per-API-call timing (no vkCmdDraw durations — Nsight 2026.1 removed GPUTrace.pyd; actions in this skill are leaf markers, not raw draw calls). Use RenderDoc/PIX for per-API timing.
  • HTML/PDF report generation — agent writes Markdown directly.
  • Capture diff (compare two runs) — future work.
  • Cross-platform — Windows only.
  • Auto-installing Nsight — doctor only detects.
  • Remote capture (ngfx-rpc) — use ngfx-rpc.exe manually if needed.
  • NVTX marker injection — game-side, not skill-side.
  • GUI launching — open ngfx-ui.exe manually for visual inspection.

© Luna5ama, GPL-3.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 80 other files (scripts, references) in .agents/skills/nsight-graphics-analyzer of Luna5ama/Alpha-Piscium.

  • SKILL.md
  • agents/openai.yaml
  • references/parameters.md
  • scripts/nsight.py
  • scripts/nsight/__init__.py
  • scripts/nsight/_io.py
  • scripts/nsight/_version.py
  • scripts/nsight/analyze/__init__.py
  • scripts/nsight/analyze/actions.py
  • scripts/nsight/analyze/headlines.py
  • scripts/nsight/analyze/stages.py
  • scripts/nsight/analyze/summary.py
  • scripts/nsight/artifacts/__init__.py
  • scripts/nsight/artifacts/layout.py
  • scripts/nsight/artifacts/writer.py
  • … and 66 more

Open the folder on GitHubat commit f2401e9

Compare with similar skills

Nsight Graphics Analyzer next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Nsight Graphics Analyzer compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Nsight Graphics Analyzer this skillLuna5ama/Alpha-Piscium156—~4.7kAutomated safety check: PassGPL-3.0
Cutlass SkillslowlyC/agent-gpu-skills169—~1.3kAutomated safety check: PassMIT
Make Op VerifyCVCUDA/CV-CUDA2.7k—~433Automated safety check: PassCustom licence
Review Op SupportCVCUDA/CV-CUDA2.7k—~248Automated safety check: PassCustom licence
Review Op Test CoverageCVCUDA/CV-CUDA2.7k—~264Automated safety check: PassCustom licence
Cudaq GuideNVIDIA/skills3.6k—~1.3kAutomated safety check: PassApache-2.0

Similar skills

  • Cutlass Skill

    slowlyC/agent-gpu-skills

    Write, debug, and optimize CUTLASS, CuTe, and CuTeDSL GPU kernels from local upstream source, examples, and headers.

    169 GitHub stars~1.3k tokensUpdated 2 mo ago
    AI & LLM EngineeringAuto-check passed
  • Make Op Verify

    CVCUDA/CV-CUDA

    Verify a new CV-CUDA operator against the deterministic final regression checklist (the /make-op done-gate).

    2.7k GitHub stars~433 tokensUpdated 23 days ago
    AI & LLM EngineeringAuto-check passed
  • Review Op Support

    CVCUDA/CV-CUDA

    Review a CV-CUDA operator's input-type, layout, dtype, and channel support matrix.

    2.7k GitHub stars~248 tokensUpdated 23 days ago
    AI & LLM EngineeringAuto-check passed
  • Review a CV-CUDA operator's test coverage, including C++ correctness, required cross-layout parity, correctness rigor, and the Python API surface.

    2.7k GitHub stars~264 tokensUpdated 23 days ago
    Testing & QAAuto-check passed
  • Cudaq Guide

    NVIDIA/skills

    Official

    A skill your agent uses for CUDA-Q setup, simulation targets, QPU access, and @cudaq.kernel authoring guidance.

    3.6k GitHub stars~1.3k tokensUpdated today
    AI & LLM EngineeringAuto-check passed
  • Cuopt Developer

    NVIDIA/skills

    Official

    Modify, build, test, debug, and contribute to NVIDIA cuOpt (C++/CUDA, Python, server, CI).

    3.6k GitHub stars~3.2k tokensUpdated today
    AI & LLM EngineeringAuto-check: notes

More from Luna5ama/Alpha-Piscium

  • Write Alpha Piscium Changelog

    Luna5ama/Alpha-Piscium

    Draft, revise, translate, and finalize Alpha Piscium stable, beta, alpha, and hotfix changelogs from Git history.

    156 GitHub stars~1.9k tokensUpdated 5 days ago
    Auto-check passed
  • Replay Nsight

    Luna5ama/Alpha-Piscium

    Use glc2vk replayers and Nsight GPU Trace for offline Alpha-Piscium diagnostics after Vibris MCP captures.

    156 GitHub stars~2.1k tokensUpdated 5 days ago
    Auto-check passed

Questions about Nsight Graphics Analyzer

What does Nsight Graphics Analyzer do?

Drive NVIDIA Nsight Graphics 2026.1+ from the command line for GPU performance analysis, frame capture, frame trace inspection, draw-call inspection, NVTX/D3DPERF stage timing, replay metadata…. Nsight Graphics Analyzer is an agent skill from Luna5ama/Alpha-Piscium.1+ from the command line for GPU performance analysis, frame capture, frame trace inspection, draw-call inspection, NVTX/D3DPERF stage timing, replay metadata extraction, and GPU Trace drill-downs.

When should I use Nsight Graphics Analyzer?

Nsight Graphics Analyzer fits situations like: the user mentions nsight; GPU performance; asks why a frame is slow on the GPU.

How do I install Nsight Graphics Analyzer in Claude Code?

Run `npx skills add Luna5ama/Alpha-Piscium --skill nsight-graphics-analyzer -a claude-code`. Or copy the skill folder (.agents/skills/nsight-graphics-analyzer in Luna5ama/Alpha-Piscium) into .claude/skills/nsight-graphics-analyzer in your project. Claude Code loads it when a task matches its description.

How do I install Nsight Graphics Analyzer in Codex?

Run `npx skills add Luna5ama/Alpha-Piscium --skill nsight-graphics-analyzer -a codex`. Or copy the skill folder (.agents/skills/nsight-graphics-analyzer in Luna5ama/Alpha-Piscium) into .agents/skills/nsight-graphics-analyzer in your project. Codex loads it when a task matches its description.

Can I use Nsight Graphics Analyzer in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add Luna5ama/Alpha-Piscium --skill nsight-graphics-analyzer -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/nsight-graphics-analyzer, .gemini/skills/nsight-graphics-analyzer, .github/skills/nsight-graphics-analyzer and .opencode/skills/nsight-graphics-analyzer in your project.

What does Nsight Graphics Analyzer need to run?

Going by SKILL.md and its folder, Nsight Graphics Analyzer needs Python for the scripts in its folder and the command-line tools its instructions call (python). Our summary lists: Python 3.

Does Nsight Graphics Analyzer access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Nsight Graphics Analyzer safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Nsight Graphics Analyzer use?

Nsight Graphics Analyzer is published under the GPL-3.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Nsight Graphics Analyzer use?

About 4.7k tokens (SKILL.md is roughly 19k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 2.3k tokens, read only when the agent opens those files.

What are the alternatives to Nsight Graphics Analyzer?

Skills that share tags, products or a category with Nsight Graphics Analyzer: Cutlass Skill (slowlyC/agent-gpu-skills, 169 stars), Make Op Verify (CVCUDA/CV-CUDA, 2.7k stars), Review Op Support (CVCUDA/CV-CUDA, 2.7k stars) and Review Op Test Coverage (CVCUDA/CV-CUDA, 2.7k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Nsight Graphics Analyzer?

Luna5ama (a GitHub user) maintains it in Luna5ama/Alpha-Piscium, which has 156 GitHub stars. The repository holds 3 skills in this directory. The repository was last updated on October 5, 2026.

Source: Luna5ama/Alpha-Piscium on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.