mrkeyoor.comAsk

shanselman/gputaskmantested 20 Nov 2026commit 95eb79c

gputaskman review

Our run installed gputaskman in 9 seconds and built it in 1 second, then the test command failed with 754 passing tests and one failure.

  • Install 1.1 s
  • README snippet failed
754/755passed, run exited non-zero
  • 13.4 MB on disk
  • 11 dependencies
Dev Toolsevaluationupdated 20 Nov 2026
+40 / 1dstars / 7d

gputaskman is a terminal GPU monitor that connects process memory and activity with clues about runtimes and local AI models. It helps explain why a model server takes more memory than its model file, while distinguishing measured counters from estimated breakdowns.

Verdict

Our run installed gputaskman in 9 seconds and built it in 1 second, then the test command failed with 754 passing tests and one failure. Use it if you run local AI models and want process memory readings connected to model files and runtime information. Skip it if you need a texture-level explanation of a game's VRAM: the project's documentation explicitly excludes that job.

gputaskman infographic: connects process memory with runtime and model context, plus our test result and who it suits
Tested 20 November 2026: the README snippet failed. Before that: 754 of 755 source tests passed; uv install took 1.1 s.

We ran it

Lab card: what happened when we ran gputaskman
Lab card from our sandbox run
Screenshot of gputaskman (github.com/shanselman/gputaskman)
github.com/shanselman/gputaskman
Install✓ · 9s41 packages · 44 MB
Build✓ · 1s
Tests✗ · 60s754 passed · 1 failed · 6 skipped of 755 (pytest)
Known vulns0(pip-audit)
Repo70 files~23,694 lines of source · 2.6 MB · 2 CI workflows · tests dir

Answers from our run

Does gputaskman build from source?

Dependencies installed in 9 seconds (41 packages), and the build succeeded in 1 seconds. We cloned commit 95eb79c into a clean Debian container with 3 CPUs and no project-specific setup.

Do gputaskman's tests pass?

No. The project's own test command finished in 60 seconds and reported 754 passed, 1 failed, 6 skipped (pytest).

Does gputaskman have known vulnerabilities in its dependencies?

pip-audit found none in the dependency tree at the time of our run.

Who should not use gputaskman?

You need a VRAM dump or an inventory of a game's textures; the README excludes both.

What are the alternatives to gputaskman?

Windows Task Manager, nvidia-smi, nvtop. Our run installed gputaskman in 9 seconds and built it in 1 second, then the test command failed with 754 passing tests and one failure.

Setup4/5In our 2026-11-20 run it installed in 1.1 s; the README gave no task we could run as written.Editor’s note: The source-check install and build succeeded, but the record contains no supported-GPU interactive setup check on which to base an ease rating.
Docs4/5The README has an install section (“Install from PyPI”) and usage examples in code; we did not run its quickstart ourselves.Editor’s note: The README explains installation routes, unavailable counters and evidence labels; instruction accuracy across supported hardware was not assessed end to end.
Community4/5Last push on 2026-11-19, 3,591 stars and maintainers answered or closed 10 of the 10 most-discussed issues we sampled.Editor’s note: Issue follow-ups include user retests on Intel, mixed-vendor and TCC hardware. This sample does not measure support response times or adoption.
Maturity1/5Latest release v0.4.4 on 2026-11-17 (pre-1.0), repository created 2026-11-03 and its test suite did not pass in our sandbox (754 of 755 passed).Editor’s note: One scan-priority test failed in our sandbox, and recording reports need counter checks. Long-running hardware reliability was not assessed.

How we score

Who it’s for

You run local language models and want model-file, cache and runtime context beside process memory readings.
You troubleshoot several GPUs and can read the availability and provenance labels for your hardware.
You want JSON snapshots to compare a workload before and after a change.

Who it’s NOT for

You need a VRAM dump or an inventory of a game's textures; the README excludes both.
Your Windows Intel workflow requires temperature, power and clocks; issue #35 says those readings are unavailable.
Your organization only permits signed Windows executables; the portable builds are unsigned.

Setup reality

Our November 20, 2026 sandbox run at 95eb79c installed successfully in 9 seconds, with 41 dependencies recorded and 44 MB on disk. The build succeeded in 1 second. Tests exited 1 after 60 seconds: 754 passed, 1 failed and 6 skipped, with 514 subtests passed in the log. pip-audit reported 0 known vulnerabilities. The failure was a first-sample scan-priority assertion in tests/test_wslhost.py.

The README offers PyPI installation with uv or pipx and portable Windows builds. Monitoring requires no API key, model download or CUDA Toolkit. It needs a supported GPU and driver, and the Python route requires Python 3.11+. Extract the entire portable ZIP, retaining _internal beside the executable. Windows portable builds are unsigned.

The recorded source-check configuration was 3 CPUs, 8 GB RAM and image label ghcr.io/astral-sh/uv:python3.12-bookworm. Actual runtime and operating-system versions require raw toolchain logs. A separate quickstart recipe stopped because it searched for a Python code block in a CLI README; that finding doesn't demonstrate a failed monitor launch. Hardware telemetry varies by platform and vendor.

Short answer

Our run installed gputaskman in 9 seconds and built it in 1 second, then the test command failed with 754 passing tests and one failure. Use it if you run local AI models and want process memory readings connected to model files and runtime information. Skip it if you need a texture-level explanation of a game's VRAM: the project's documentation explicitly excludes that job. The useful purchase decision here costs no money, but it does cost your attention: do the model clues answer a question your existing monitor leaves open?

Windows Task Manager already has per-process GPU memory. gputaskman's appeal is the explanation beside the reading, especially for a local language-model server. Its README separates measured counters from estimated model breakdowns, and Ty Sherback's XDA hands-on review shows that extra context in use. Keep that distinction when deciding which numbers to act on.

What people use gputaskman for

gputaskman connects process GPU memory and activity to runtime and model evidence in a terminal interface, according to the project documentation. VRAM means a graphics card's video memory. A runtime is the software layer doing the work, such as CUDA or llama.cpp. For a local large language model, the interesting question is often why its process consumes more memory than the model file occupies on disk.

The inspector can connect a process with a model and explain weights, KV cache and compute buffers. Weights are the model's learned values; KV cache stores attention data used during generation. In Sherback's llama-server inspection, the breakdown came from runtime logs. Without those logs, he describes the KV figures as estimates derived from model metadata. A number that explains an allocation is more useful when you also know how the program obtained it.

For a repeatable investigation, the README documents JSON snapshots and a before/after diff. Save a snapshot, load your model, send one request, then save another and compare them. The comparison keeps measured memory changes separate from runtime-reported segments and estimates. That's a sensible way to investigate a context-size change without treating a model's theoretical cache budget as memory it necessarily consumed.

Users have reported model inspection, mixed-vendor discovery and compute-only NVIDIA monitoring, with different levels of corroboration.

Who used it What they did What came back
XDA reviewer Ty Sherback Loaded Qwen3-8B on a Radeon RX 9070 XT Reported 7.37 GB used overall, with 1.37 GB against dwm.exe and 1.14 GB against Brave. These process readings are not a claim of exclusive ownership or an additive total.
XDA reviewer Ty Sherback Selected llama-server in the inspector Reported 4.35 GB weights, 576 MB KV cache and 108 MB compute buffers from llama.cpp logs.
GitHub user gamedevsam Tried the multi-GPU update alongside a home-grown monitoring dashboard Confirmed that all GPUs appeared, including the integrated GPU, then requested a less crowded view.
GitHub user cmillsap Checked a Windows desktop with two NVIDIA cards and a Radeon integrated GPU Reported that v0.3.3 listed all three adapters and JSON output worked for each.
GitHub user etaduck Ran llama.cpp on a headless P102-100 in Windows TCC mode Posted a v0.4.2 llama-server row showing 9.51 GB. The triage reply explicitly separates this report from an independent nvidia-smi comparison.

Sherback's desktop is the most relatable example if you mix local models with ordinary PC use. The compositor and browser appeared beside the model, giving him specific processes to investigate before blaming the model's size. His allocation breakdown also answers a more technical question: the model file's weight size is only one part of a server's memory requirement. Those are his hardware observations, rather than results from our sandbox.

The TCC report took two steps. First etaduck posted an idle snapshot with the P102-100 detected and an empty process table. A triage agent asked for a workload snapshot; etaduck then posted the llama-server row. That sequence supports a stronger conclusion about process reporting than the idle screenshot alone, while keeping the accuracy question separate.

What happened when we ran it

Our sandbox run installed gputaskman in 9 seconds, built it in 1 second and failed the test step after 60 seconds. We checked commit 95eb79c on November 20, 2026, with a recorded configuration of 3 CPUs, 8 GB RAM and image label ghcr.io/astral-sh/uv:python3.12-bookworm.

Check Our recorded result
Dependency installation Succeeded in 9 seconds; 41 dependencies recorded; 44 MB on disk
Build Succeeded in 1 second
Tests Exit 1 after 60 seconds; log summary: 754 passed, 1 failed, 6 skipped, 514 subtests passed
Dependency audit pip-audit reported 0 known vulnerabilities
Repository scan 70 files, approximately 23,694 source lines, 2.6 MB checked out
Automation signals 2 CI workflow files, a tests directory, no Dockerfile detected

Installation and build completed. Then pytest reached test_current_inferred_vram_sets_first_sample_scan_priority in tests/test_wslhost.py and failed an assertion: PID 25 appeared in the scan-call list even though the test expected it to be absent. The actual list began with PID 26 and ended with PID 25. The failure concerns which processes received a deep scan on the first sample; the log alone doesn't identify the cause or demonstrate a broken hardware monitor.

The pytest tail gives 57.31 seconds for the suite, while the harness records 60 seconds for the test step. Its passing and failing counts are clearer than its headline denominator: the parser says “of 755” while also listing six skipped tests, so the table preserves the log's separate counts. A successful build and hundreds of passing tests are useful contributor evidence, but the suite wasn't green.

A separate November 20 quickstart attempt used an unprivileged container. Its automation selected a library-style recipe and stopped because the README had no Python code block to run. That is a recipe mismatch for a terminal application, rather than evidence that the documented CLI failed. The teardown record says cleanup completed. The installation figures above all come from the source-check harness; they are not blended with that separate attempt.

Where people get stuck

The most actionable reports concern malformed Ollama manifests, unfamiliar model flags and GPU recovery after a driver-state change.

Symptom What the reporter found Resolution or next step in the thread
Opening an Ollama model closes the monitor bitli's issue #33 reports TypeError: 'NoneType' object is not iterable. A triage agent reproduced a manifest with layers: null. The merged fix skips malformed manifests. bitli said v0.4.0 worked, while allowing that the Ollama store might also have changed.
A large consumer has no model listing RAFOLIE's issue #48 describes Strata passing a GGUF file under --native. RAFOLIE confirmed the correct path appeared with path-arg provenance after updating to merge commit ef599e5.
Re-enabled laptop GPU stays absent or loses telemetry raenye's follow-up in issue #7 reports rapid rediscovery in v0.3.4. The card came back, but the tester also saw the message requiring a gputaskman restart to restore NVIDIA telemetry.
Intel shared memory is labelled as VRAM win7guru's issue #35 led to integrated-memory and activity changes. The triage agent says the fixes shipped in v0.4.1; later v0.4.3 snapshot interpretation reports Iris Xe activity and shared memory.

The Strata fix is particularly useful if you run a less familiar server. A valid model path passed under a custom flag is a clue, but it says less than a model-specific flag the monitor recognizes. The new label preserves that difference. RAFOLIE also corrected the original report: the process did have a CUDA runtime tag; it lacked a recognized AI-framework tag. Repeating the initial “no runtime” description would misstate the outcome.

If the full diagnostic screen is too crowded, the documented m shortcut switches to slim monitoring for the session. gamedevsam's complaint in issue #7 was about static details taking attention away from monitoring. You can keep a deep inspection view for troubleshooting and use the quieter display while watching a workload.

Long recordings need a counter sanity check

Madhur-Prakash checked a summary against an eight-hour training recording and found matching calculations, while the recording itself contained extreme process GPU percentages.

In issue #68, Madhur-Prakash reports that the sample count, time span, averages, peaks and top processes matched their own summary. The file held 2,930 samples from a Windows 11 system with an RTX 4060 Laptop GPU. That is a concrete user check of the summarizer's arithmetic on one saved file, rather than a measurement of gputaskman's overhead or its effect on training speed.

The same report identifies 15 process rows with GPU activity around 18,450,000,000,000%. The triage reply says the summary change merged and a column-overlap problem was fixed, then asks for a separate issue about the suspected counter wraparound. It does not report that anomaly resolved. A summary can faithfully calculate a peak from bad input.

The current README describes rejecting non-finite, negative or above-1000% Windows process-engine counters, making those readings unavailable. That documented safeguard is a separate fact from the historical recording. If your saved file contains impossible peaks, inspect the underlying samples before using its summary to describe a training run.

Security starts with the executable and the snapshot

The project documents unsigned Windows portable builds with checksum companions, and monitoring requires no API key or model download.

For the portable Windows route, the README says to extract the entire ZIP and keep _internal beside the executable. Choose the native x64 or ARM64 build for your machine. A checksum helps check the downloaded file's integrity; it does not supply the publisher identity of a signed executable. If your employer requires signed software, that distribution detail can settle the decision before any GPU feature does.

Our dependency audit reported zero known vulnerabilities. That result covers the audit performed in our sandbox, rather than the safety of every executable, driver interaction or future dependency revision. Snapshots can contain process and model-path information: the recording discussion specifically asks for affected lines with paths removed. Apply the same care before attaching your own diagnostic file to a public issue.

gputaskman vs Task Manager, nvidia-smi and nvtop

Task Manager already supplies per-process GPU memory; gputaskman adds workload and model context around those readings.

Alternative Pick it when Reason to consider gputaskman instead
Windows Task Manager You need to identify a process's GPU memory without another application Sherback explains that Details has a Dedicated GPU memory column, while gputaskman adds classification and model inspection.
nvidia-smi You want NVIDIA's device and process tooling Windows WDDM can leave process memory unavailable through NVML; TCC uses a different reporting path. gputaskman combines platform counters with model context.
nvtop You want a terminal GPU monitor across supported vendors nvtop's README documents multiple GPUs and vendor-specific backends. gputaskman's particular attraction here is local-model evidence, the distinction identified in Remio's comparison.

If your question is simply which program is touching the GPU, BetaNews describes NVIDIA's GPU Activity taskbar icon as a simpler list. Start with the information you need. Installing a more detailed monitor pays off when the runtime or model inspector changes what you'd investigate next, rather than just giving you another utilization chart.

What the other reviews get wrong

Several launch stories overstate Task Manager's blind spot or repeat requirements that later documentation contradicts.

Page Claim to correct What to use instead
TweakTown Task Manager only provides a simple VRAM total XDA's hands-on review identifies its per-process Dedicated GPU memory column. The difference is explanatory context.
TweakTown The tool shows exactly where VRAM is allocated The README distinguishes counters from estimated classifications and excludes VRAM dumps and game-texture enumeration.
The FPS Review macOS requires Python 3.1; Windows Mobile is supported The README specifies Python 3.11+ and 64-bit Windows 10/11 desktop support. It gives no basis for the Windows Mobile claim.
The FPS Review Linux and WSL can be grouped together as NVIDIA or AMD The documented overview separates NVIDIA across Linux/WSL from AMD and Intel on native Linux. Don't read that wording as confirmation of AMD under WSL.
Shattered Intel GPUs are not listed The later Iris Xe thread includes detection, activity and shared-memory observations.
iThub v0.4.1 is the latest release Later user testing in issue #35 covers v0.4.3. That latest-release label is stale.
BetaNews Mac users must clone the repository The README also offers PyPI installation for macOS. A missing portable Mac download doesn't require a clone.

Questions people ask

You can inspect which processes use GPU memory, then use gputaskman's runtime and model clues to investigate what those processes are doing. The README distinguishes those clues from measured counters.

What is actually using my GPU memory?

Task Manager's Details view can already show dedicated GPU memory by process. Sherback's review shows how gputaskman adds workload categories and a model inspector, useful when a server's memory requirement includes cache and buffers alongside weights.

Does gputaskman support Intel GPUs on Windows, including Iris Xe?

Yes: win7guru posted Iris Xe exports and a Copilot triage agent interpreted v0.4.3 snapshots as showing detection, 2-3% activity and roughly 727-728 MB shared memory. The agent explicitly warns that spreadsheet values differed. Intel temperature, power and clocks remain unavailable on Windows in that thread.

Can gputaskman monitor all GPUs in a multi-GPU system?

Yes: gamedevsam confirmed all their GPUs appeared, and cmillsap reported two NVIDIA cards plus a Radeon integrated GPU in v0.3.3. cmillsap also checked JSON output for each adapter. These are reports on particular machines, rather than a guarantee for every combination of drivers.

Why does a GPU disappear after I disable and re-enable it?

An older adapter-discovery problem is described in raenye's issue #7 follow-up. Their v0.3.4 retest found the GPU quickly after enabling it, but NVIDIA telemetry still requested a monitor restart. Device rediscovery and telemetry recovery are separate outcomes.

Why does gputaskman miss a Windows TCC-mode NVIDIA card that nvidia-smi can see?

TCC is NVIDIA's compute-only driver mode; the original issue #14 explains that these cards were missing from the Windows display-adapter enumeration. The NVML-only path shipped in v0.4.2, and etaduck subsequently posted P102-100 detection and a running llama-server row.

Why does opening an Ollama model crash gputaskman?

A malformed model-store manifest caused the NoneType crash in bitli's issue #33. The fix skips a manifest whose layers value is null. bitli reported success with v0.4.0, with the qualification that their store may also have changed. That specific report is a useful match for that traceback, not a diagnosis of every Ollama crash.

Why does my biggest GPU-memory consumer show no model when its launch command includes a GGUF path?

A custom model flag can escape the recognized flag list. In issue #48, RAFOLIE confirmed that the Strata --native path appeared after merge commit ef599e5. The path-arg label means the path was passed at launch, a weaker clue than a recognized model flag.

Does gputaskman support Windows 7, Windows 8 or older Windows Server releases?

The README targets 64-bit Windows 10/11. In issue #55, Hanselman declines Windows 7 support and notes Python 3.11's incompatibility. A commenter links a separate port; that isn't upstream support for older desktop or Server editions.

Can I install gputaskman from PyPI with pipx or uv?

Yes: the README documents pipx install gputaskman and uv tool install gputaskman, followed by the gputaskman command. The PyPI request in issue #4 ends with Hanselman linking the published package.

Can I run gputaskman on Windows without downloading Python?

Yes: the portable Windows ZIPs contain an executable and its supporting files. Extract the whole archive, retain _internal, and choose x64 or ARM64. The distributions are unsigned.

Is there a slim monitoring mode that hides static diagnostic details?

Yes: the documented m toggle switches between full diagnostics and slim monitoring for the current session. That option follows the information-overload complaint in gamedevsam's multi-GPU discussion.

Can gputaskman summarize a saved recording?

Yes: issue #68 records the merge of gputaskman summary and Madhur-Prakash's check against their own calculations. Inspect suspicious source percentages before accepting the peak GPU figure in a saved file.

What we have not tested yet

Our sandbox checks establish installation, build and test outcomes at 95eb79c, not GPU-counter accuracy on real hardware. We did not reproduce the XDA workload, compare the TCC readings against nvidia-smi, or run the Intel and mixed-vendor machines described by users. The configured image label does not establish actual Python or operating-system versions; those require the raw toolchain logs.

We have no measured CPU overhead, idle RAM use or workload-performance penalty for the monitor. The terminal interface alone cannot substantiate a tiny-footprint claim. Nor do GitHub attention or a dependency audit establish broad adoption, executable safety or reliable operation over weeks. The r/pcmasterrace discussion contains sharply different opinions rather than a reproducible workload, the r/gpu link has no comments, and preprintpigeon's X reply explicitly says there was no test by them. The Bilibili search result lists a gputaskman video, but contains no transcript from which to judge its demonstration.

The recording thread leaves the extreme-percentage anomaly unresolved; the current README's rejection rule still needs a controlled reproduction against that case. We also have no fresh hardware check of the README's revised container PID attribution: it labels order-based local matches as guesses and separates measured host rows. Those boundaries matter if you share a GPU between containers. For your first investigation, preserve the snapshot, the driver version and the model's launch arguments together so that an unexplained reading can become a reproducible issue.

Alternatives

ProjectWhat it isPick it when
Windows Task ManagerBuilt-in Windows process monitoring with an optional Dedicated GPU memory column.Use it when process memory is enough and you do not need local-model inspection.
nvidia-smiNVIDIA's GPU tooling, with different process-memory visibility under WDDM and TCC.Use it for NVIDIA device and process checks, including a reference comparison for TCC readings.
nvtopA terminal task monitor for multiple GPUs and accelerators with vendor-specific backends.Use it when general GPU process monitoring on its supported platforms covers your question.

What people are saying

  1. [velocity-scout] shanselman/gputaskman

Sources

  1. gputaskman documentation
  2. XDA: Ty Sherback hands-on review
  3. Multi-GPU and recovery reports
  4. Windows Intel GPU reports
  5. Windows TCC hardware report
  6. Recording summary and anomalous counters
  7. Custom model flag fix
  8. nvtop documentation

More dev tools reviews