On GDDR7/Blackwell (measured: RTX 5090, driver 615.78.08) the memory
V/F offset NVML APIs operate in a domain 2x the memory clock NVML
reports. Applying +3000 moved the under-load clock by only +1500 MHz;
the driver range -2000..+6000 maps to NvAPI's -1000..+3000.
- limits.py: multiply by _MEM_OFFSET_DOMAIN_FACTOR (2) on set, divide
on get/readback/range for the MEM domain only; GPC untouched.
API/CLI/profiles/UI now all speak the reported-clock domain
(what nvidia-smi shows), so a +3000 slider value reaches the
driver's full +6000 headroom (old UI half-used it).
- limits.py: call nvmlDeviceGet/SetClockOffsets via the raw function
pointer for the real driver return code - nvidia-ml-py wrappers
discard it and always report success, which would have masked
erroring drivers and skipped the deprecated-API fallbacks.
- PerformancePanel: fallback range -1000..+3000, remove stale
Math.min(max, 3000) cap that clamped the new max, add domain tooltip.
- Docs: document the domain conversion (API.md, Usage-Guide.md).
GSP transiently rejects NV0080 object allocation with status 0x1f when
busy — reliably on the first probe in a fresh server process and
intermittently right after RM operations (e.g. a power-limit write).
The probe surfaced that transient rejection as rm_power_supported=false,
making the Experimental Power Control block disappear in the UI until a
reload re-probed successfully.
- hal/rm_power: RmHandle.open() now retries the handle allocation
(3 attempts, 100 ms apart) before reporting the interface unavailable;
covers probe, set, and enable-check paths. Each attempt cleans up its
own fds, so retries are safe and idempotent.
- PerformancePanel: confirm a negative rm_power_supported reading with
one follow-up fetch before rendering it, so a single flaky probe can't
hide the block or flip it into "interface unavailable"; the confirm
has its own error boundary so a failed second request keeps the first
(valid) read. Also added a monotonic fetch-seq guard so a slow
response for a previously selected GPU cannot clobber fresher state.
- tests: cover transient-failure-retry and persistent-failure paths for
RmHandle.open.
Verified live: first probe after restart 5/5 (was 0/3), 150 rapid
set+get cycles with 0 probe flips and 0 set failures.
- server.py: claim the flash (state=bootloader) before spawning the task so
the concurrent-request guard is effective immediately; guard the bundled
image existence in the flash endpoint; single device.info() call per
endpoint; 400 for refused flashes (409 stays for already-running);
remove stale nvcurve-wireview-fw-*.bin temp files at startup
- wireview_firmware.py: drain stderr in its own reader thread (a full pipe
buffer would have hung the flash until timeout); chunked stdout reads
instead of per-character read(2); BuildStruct field checks in dataclass
order
- wireview.py: document the intentional 0xF1 overlap between CMD_BOOTLOADER
and SCREEN_RESUME_UPDATES (different command namespaces)
- tests: check() now fails loudly under pytest (optional import, standalone
runs unaffected); explicit reader-thread sync in test_enter_bootloader;
less brittle flash-progress assertion; self-documenting checksum
corruption in test_hex_parser
- frontend: refreshFirmware in useCallback + effect deps; NaN% guard on
flash.progress; explicit clear/keep masks in handleClear; WS firmware
message reuses WireViewFlashProgress via Pick
- docs: clarify that the dfu-util :leave modifier is what makes the device
exit the bootloader and reboot; document the 400 vs 409 API contract;
README now mentions per-pin readings, pin-imbalance gauge and fault
clearing
- WireViewSerialDevice.clear_faults() sends CMD_CLEAR_FAULTS (0x0E)
with 16-bit keep masks (0x0000 clears, 0xFFFF keeps); all port
access is now serialized with an RLock so the poller, the
clear-fault endpoint and the watchdog cannot interleave on the
port mid-transaction.
- POST /api/wireview/clear-fault (serial transport only — in hwmon
mode wireviewd owns the port and the masks are read-only); the
sample is re-read immediately so clients see the cleared masks
without waiting for the next poll tick.
- WireView tab: Clear buttons on the fault status/log badges.
- tests: protocol-level clear-fault tests via pty (byte-exact
command framing, keep-mask semantics).
Port of the wireview-linux firmware update feature:
- nvcurve/wireview_firmware.py: Intel-HEX parser (checksum-verified),
BuildStruct identity extraction (vendor/product/version/build string
at image base + 192), compatibility verdicts (version then build
date, Noctua Edition product alias + 2026-09-02 floor), and a
dfu-util flasher (progress parsing, exit-74-after-:leave quirk,
timeouts).
- Bundle TG-WV-PRO2-FW.hex (v05, build 20260902_0741, base
0x08000000) in nvcurve/firmware/.
- WireViewSerialDevice.enter_bootloader() sends the top-level 0xF1
command; vendor/product ids are exposed in info().
- GET /api/wireview/firmware (device vs. bundled verdict, dfu-util
availability, flash state) and POST /api/wireview/firmware/flash
(gates: serial transport, product match, Noctua floor, downgrade/
same require override). The flash runs as a background task
(bootloader -> wait for 0483:df11 -> dfu-util) with progress
streamed over /ws/wireview.
- WireView tab: Firmware card with device vs. bundled firmware,
verdict, dfu-util/hwmon warnings, confirm dialog, live progress
bar; re-checks after the device reboots.
- tests/test_wireview_firmware.py: 66 tests (HEX parser, checksum
rejection, identity, all verdict paths, mocked flasher, bootloader
command via pty); added to the Makefile test target.
- Docs: firmware section in docs/WireView.md, README note.
- Per-pin bar now scales against the 9.2 A per-pin rating (10 A full
scale, red at/over rating) instead of the 55 A total connector OCP
- Debounced app-wide warning banner (visible on all tabs) when the
current between two pins diverges by > 2 A for ~7 s - the signature
of a bad pin contact that can overheat and melt the 12VHPWR
connector; 5 s grace period after clearing
- New pin_imbalance_a sample field (max - min pin current) in both the
serial and hwmon sample builders, plus frontend type
- Docs: README + WireView.md cover the warning and threshold; fresh
screenshot with the new per-pin labels
- Tests: vitest setup + 9 unit tests for the debounce state machine;
3 new backend checks for pin_imbalance_a
Adds a 'Report Bug' button to the web UI (top bar) that files an issue
on Gitea via the daemon. The issue body is enriched with auto-collected
context: nvcurve version, hostname, GPU name, applied offset summary,
active profile, and a collapsed tail of the recent server log.
Security model:
- The Gitea token (nvcurve_bot, scope write:issue) is embedded as a
built-in default so the feature works out of the box for every
install of this public repo — no configuration required.
- The token is only ever used server-side; it never reaches the
browser, logs, or API responses.
- The endpoint is behind the existing session auth when enabled, and
rate-limited to one report per 5 minutes per client IP.
- config.json can override gitea_url/gitea_repo/gitea_token (e.g.
forks pointing at their own repo); gitea_token: '' disables it.
Add a GPU process table to the Performance tab showing which processes
use the selected GPU, with per-process VRAM, GPU utilization, CPU, host
memory, and command. Includes a kill endpoint (SIGTERM/SIGKILL, with
optional parent kill) behind a confirm dialog.
- nvcurve/hal/processes.py: NVML + /proc process enumeration
- server.py: GET /api/processes, POST /api/processes/kill (refuses to
signal init/kthreadd)
- frontend: ProcessList component, API client, types
- tests: test_processes.py
- docs: API reference for the new endpoints
Standalone support for the ThermalGrizzly WireView Pro II without
depending on the external wireview_reporter exporter:
- wireview.py: serial protocol (STX/ETX + 16-bit CRC16-CCITT) with
vendor-data product identification, config version, UID, build
string, screen layout, and temperature/power/current sensor reads;
hwmon fallback with per-channel index resolution; udev-based
detection (vendor 0x2560 / product 0x0101) with fallback port
probing; serial read timeout and watchdog reconnect
- server.py: startup detection (root only), 1 Hz poller gated on
subscribed clients, WS 'wireview' channel, GET /api/wireview,
rejected-product memoization, stale-read race guard
- frontend: WireView tab (visible when a device is detected) with
live temperature/power/current cards, sparkline history, and
device info; nullable temp channels
- tests: 76 tests covering parser, CRC, fault classification,
hwmon resolution, JSON safety, and the serial transport against
a pty-based fake device
Verified live: tab appears with the device connected, disappears
when unplugged, reconnects on re-plug, no serial traffic when idle.
Adds an experimental power-cap mode using the undocumented RM ioctl
interface (based on panchovix's LACT PR #1205) to set power limits
below the VBIOS minimum (down to 30 W).
- hal/rm_power.py: RM ioctl power-cap read/write/reset + runtime probe
- limits.py: power_cap_mode (nvml/ioctl) with support detection
- config.py: persist power_cap_mode per GPU
- profiles: record/apply power_cap_mode
- server.py: POST /api/limits validates ioctl support (409 on failure)
- cli.py: profile save falls back to persisted mode
- client.py: power_cap_mode in Limits
- frontend: toggle + warning with panchovix attribution (LACT #1205)
- tests: test_rm_power.py (unit) + integration coverage
- Makefile: add test_rm_power.py to make test
Also includes automated linter reformatting (prettier, ruff, shellcheck,
isort, markdownlint) that the linter would apply anyway.
The fan curve previously only controlled fan index 0; secondary fans
stayed on driver control. The curve can now target all fans (new
default) or any individual fan(s).
Backend:
- hal/fans.py: get_num_fans() via nvmlDeviceGetNumFans; get_fan_info()
returns per-fan speeds; set_fan_speed() accepts a fan index list
(None = all fans; all-fans mode is lenient toward driver-locked
fans, explicit lists are strict); reset_fan() restores all fans.
- server.py: per-GPU fan_targets state; the poller applies the curve to
all target fans and logs write failures (once per distinct error);
activation validates targets against the hardware (stale indices fall
back to all fans); POST /api/fans accepts fans, POST /api/fans/speed
accepts a fan index, GET /api/fans returns num_fans/fans/fan_targets.
- Persistence format is now {"curve": ..., "fans": ...}; legacy
bare-curve entries migrate to "all fans" at startup.
- Profiles save/apply fan_targets alongside fan_curve.
- MonitoringSample carries per-fan speeds for live gauges.
Frontend:
- Fans tab: All / Fan 1 / Fan 2 / ... selector with live per-fan %;
the selection is applied together with the curve.
- Live monitor: per-fan gauges with sparklines for multi-fan GPUs.
Address three fan-settings issues:
1. Profile view: show a fan icon next to a profile's name when it has a
saved fan curve, so it's clear which profiles carry custom fans.
2. Fan curve persistence: the active fan curve was in-memory only and lost
on every server restart. It is now persisted per-GPU in
/etc/nvcurve/config.json (fan_curves) and re-applied at server startup,
so an applied curve survives restarts. All fan-curve state changes route
through _activate_fan_curve/_deactivate_fan_curve helpers that keep the
persisted state in sync (apply, reset, and profile apply).
3. Point removal: the fan-curve remove button was nearly invisible. The
chart remove control is now always faintly visible with an X glyph, the
table remove button is larger with a tooltip, and a hint line explains
how to add/remove points.
Also includes a formatting pass over the two edited frontend files.
Add a new Dashboard tab as the default/first tab (Dashboard - Curve -
Performance - Fans) showing a full GPU overview.
Backend:
- New hal/dashboard.py: one-shot static GPU info via NVML (VBIOS, CUDA
cores, compute capability, bus width, BAR1/CPU-accessible VRAM,
Resizable BAR, PCIe max, max clocks, power limits, temp thresholds,
persistence mode, fan count, serial, board part number, UUID).
ROP count and VRAM type are best-effort from a per-model table since
NVML does not expose them.
- New /api/dashboard endpoint.
- MonitoringSample gains live throttle_reasons (+label), PCIe link
width/generation (downclocks when idle, so read per poll), and VRAM
temp (from the MEMORY thermal sensor, if exposed).
Frontend:
- New Dashboard component: critical top row (throttling, voltage,
GPU/VRAM temps), full live-monitor grid with sparklines, and a static
GPU-information grid. Unavailable fields are omitted.
- useDashboard hook + DashboardInfo type + api.client dashboard().
Also: restrict CORS to localhost origins (end-anchored), make
_int_key_deltas fail closed on bad keys, and clean up lint blockers in
server.py/monitoring.py.
Add optional login protection for the web UI/API, intended for shared
machines (e.g. AI servers). Dual mode: with no users configured the API
and web UI are open (as before); once at least one user exists, every
/api/* and /ws/* endpoint requires a valid session.
- bcrypt password hashing: passwords stored as $2b$ hashes in
/etc/nvcurve/users.json (0600, root-owned); plaintext never persisted.
- 24-hour sessions: HttpOnly cookie for browsers, Authorization: Bearer
token for CLI/scripts; in-memory, invalidated on server restart.
- Multi-user: multiple named accounts (no shared-password mode).
- New CLI: nvcurve user add|list|remove|set-password (root for mutating
ops; password always prompted, never a CLI argument).
- New endpoints: GET /api/ping (public), /api/auth/status|login|logout|users.
- Web UI: sign-in screen when auth is enabled; status bar shows the
signed-in user with sign-out; expired sessions (401) re-show sign-in.
- Brute-force lockout: 10 failed logins/IP within 5 min -> 15 min lockout.
- New dependency: bcrypt.
Also: LSP config (pyrightconfig.json) pointing at the project .venv, and
small error-handling cleanups in daemon.py/server.py.
- Backend HAL (hal/fans.py): NVML v2 fan read/set/reset with min/max queries
- Server endpoints: GET/POST /api/fans, POST /api/fans/reset, POST /api/fans/speed
- Background fan poller: reads GPU temp every 2s, interpolates fan speed from curve
- Profile integration: fan_curve field saved/applied, auto-restore on shutdown
- Frontend: FanCurveEditor (SVG chart with drag/add/delete points), FanMonitor sidebar
- App.tsx: three-tab layout (Curve, Performance, Fans)
- GaugeCard: optional history sparkline, Fan Mode card without sparkline
- fan_mode field populated as 'curve' or 'auto' in GET /api/fans