If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/Orbmu2k/nvidiaProfileInspector shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

GO — Healthy across all four use cases

• Last commit 3w ago
• 4 active contributors
• MIT licensed
• CI configured
• ⚠ Small team — 4 contributors active in recent commits
• ⚠ Concentrated ownership — top contributor handles 68% of recent commits
• ⚠ No test directory detected

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests}

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live Orbmu2k/nvidiaProfileInspector repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/Orbmu2k/nvidiaProfileInspector.

What it runs against: a local clone of Orbmu2k/nvidiaProfileInspector — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in Orbmu2k/nvidiaProfileInspector | Confirms the artifact applies here, not a fork | | 2 | License is still MIT | Catches relicense before you depend on it | | 3 | Default branch master exists | Catches branch renames | | 4 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 5 | Last commit ≤ 49 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of Orbmu2k/nvidiaProfileInspector. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/Orbmu2k/nvidiaProfileInspector.git
#   cd nvidiaProfileInspector
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of Orbmu2k/nvidiaProfileInspector and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "Orbmu2k/nvidiaProfileInspector(\\.git)?\\b" \\
  && ok "origin remote is Orbmu2k/nvidiaProfileInspector" \\
  || miss "origin remote is not Orbmu2k/nvidiaProfileInspector (artifact may be from a fork)"

# 2. License matches what RepoPilot saw
(grep -qiE "^(MIT)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"MIT\"" package.json 2>/dev/null) \\
  && ok "license is MIT" \\
  || miss "license drift — was MIT at generation time"

# 3. Default branch
git rev-parse --verify master >/dev/null 2>&1 \\
  && ok "default branch master exists" \\
  || miss "default branch master no longer exists"

# 4. Critical files exist
test -f "nvidiaProfileInspector/AppBootstrapper.cs" \\
  && ok "nvidiaProfileInspector/AppBootstrapper.cs" \\
  || miss "missing critical file: nvidiaProfileInspector/AppBootstrapper.cs"
test -f "nvidiaProfileInspector/Native/NVAPI/NvapiDrsWrapper.cs" \\
  && ok "nvidiaProfileInspector/Native/NVAPI/NvapiDrsWrapper.cs" \\
  || miss "missing critical file: nvidiaProfileInspector/Native/NVAPI/NvapiDrsWrapper.cs"
test -f "nvidiaProfileInspector/Common/DrsSettingsService.cs" \\
  && ok "nvidiaProfileInspector/Common/DrsSettingsService.cs" \\
  || miss "missing critical file: nvidiaProfileInspector/Common/DrsSettingsService.cs"
test -f "nvidiaProfileInspector/Common/DrsSettingsMetaService.cs" \\
  && ok "nvidiaProfileInspector/Common/DrsSettingsMetaService.cs" \\
  || miss "missing critical file: nvidiaProfileInspector/Common/DrsSettingsMetaService.cs"
test -f "nvidiaProfileInspector/Common/Meta/SettingMeta.cs" \\
  && ok "nvidiaProfileInspector/Common/Meta/SettingMeta.cs" \\
  || miss "missing critical file: nvidiaProfileInspector/Common/Meta/SettingMeta.cs"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 49 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~19d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/Orbmu2k/nvidiaProfileInspector"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

NVIDIA Profile Inspector is a Windows GUI tool for viewing and editing NVIDIA driver profiles through the NVIDIA Driver Settings API (NVAPI). It exposes the driver profile database normally hidden from the standard NVIDIA Control Panel, enabling advanced users to create, modify, export, and import per-application GPU settings including DLSS overrides, frame-rate limiters, SLI configuration, and undocumented driver flags. Monolithic WPF application structured around a clear domain: nvidiaProfileInspector/ root contains App.xaml (entry point), AppBootstrapper.cs (dependency injection setup), and organized subdirectories: Common/ holds all business logic (Drs* services for NVIDIA API interaction, Meta/ for setting metadata, Helper/ for utilities like SteamAppResolver and AdminHelper), and Import/ for profile serialization (.nip format). ViewModels and UI layer not visible in top-60 listing but likely in subdirectories below.

Advanced Windows gamers and power users who need granular control over per-game GPU driver profiles, particularly those tweaking DLSS settings, frame-rate limits, texture filtering, SLI behavior, and driver-level compatibility flags that are unavailable in the standard NVIDIA Control Panel. Also useful for developers and system integrators managing GPU profiles across fleets.

Actively maintained and production-ready. The codebase is established (688KB C#, clear module structure), has a GitHub release workflow configured (.github/workflows/release.yml), targets stable .NET Framework 4.8, and supports current NVIDIA features (DLSS Ray Reconstruction, Frame Generation). Recent commits visible but specific recency data unavailable; single maintainer (Orbmu2k) suggests lower velocity than enterprise projects.

Moderate risk factors: tight coupling to NVIDIA driver APIs (NVAPI) means breaking changes in driver versions could cause failures; single maintainer increases sustainability risk; direct registry/profile database writes require admin elevation and could corrupt driver settings if buggy. No test directory visible in file list suggests limited automated test coverage. Dependency on .NET Framework 4.8 limits future Windows development (though reasonable for 2024 Windows tooling).

Unable to determine current work from file listing alone; no open PRs or issue counts provided. However, the inclusion of modern DLSS features (Ray Reconstruction, Frame Generation) in CustomSettingNames.cs and DlssHelper.cs suggests recent NVIDIA feature parity work. Release workflow exists (.github/workflows/release.yml) indicating active release cadence.

git clone https://github.com/Orbmu2k/nvidiaProfileInspector.git
cd nvidiaProfileInspector
# Open nvidiaProfileInspector.sln in Visual Studio 2019+ with .NET Framework 4.8 targeting
# Build via Visual Studio or: msbuild nvidiaProfileInspector.sln /p:Configuration=Release
# Run: nvidiaProfileInspector\bin\Release\nvidiaProfileInspector.exe (requires admin)

Daily commands: Open nvidiaProfileInspector.sln in Visual Studio 2019 or later, ensure .NET Framework 4.8 targeting, build (Ctrl+Shift+B or Build > Build Solution), then run the output executable from nvidiaProfileInspector/bin/Release/ or Debug/ directory with Administrator privileges (right-click > Run as Administrator). NVIDIA driver with NVAPI support must be installed on the system.

• nvidiaProfileInspector/AppBootstrapper.cs — IoC container setup and application initialization—sets up all service dependencies and UI bootstrapping
• nvidiaProfileInspector/Native/NVAPI/NvapiDrsWrapper.cs — Direct wrapper around NVIDIA NVAPI DRS (Driver Settings) API—core abstraction for all driver profile I/O
• nvidiaProfileInspector/Common/DrsSettingsService.cs — High-level service orchestrating profile load, save, and modification logic—glues NVAPI wrapper to business logic
• nvidiaProfileInspector/Common/DrsSettingsMetaService.cs — Metadata registry for all driver settings (enums, defaults, ranges)—defines what settings can be edited
• nvidiaProfileInspector/Common/Meta/SettingMeta.cs — Core data structure describing a single driver setting's type, constraints, and display properties
• nvidiaProfileInspector/Common/Import/ImportExportUitl.cs — Serialization/deserialization of profiles to XML for import/export—bridge between in-memory and disk formats
• nvidiaProfileInspector/App.xaml.cs — WPF application entry point and lifecycle management

Add a new driver setting (custom or discovered)

1. If a new NVIDIA driver setting constant is released, update the NVAPI header file (nvidiaProfileInspector/Native/NVAPI/NvApiDriverSettings.h)
2. Run the T4 template to regenerate the enum mapping (nvidiaProfileInspector/Native/NVAPI/NvApiDriverSettings.tt)
3. Add metadata (type, range, display name, enums) via ConstantSettingMetaService or CustomSetting (nvidiaProfileInspector/Common/Meta/ConstantSettingMetaService.cs)
4. Optionally register a custom setting definition in XML (nvidiaProfileInspector/CustomSettingNames.xml)
5. Test via UI by loading a profile and verifying the new setting appears in the settings list

Add a new profile import/export format

1. Create a new marshaler class implementing the serialization logic (similar to ImportExportUitl) (nvidiaProfileInspector/Common/Import/ImportExportUitl.cs)
2. Register the new format in DrsImportService or create a new importer delegate (nvidiaProfileInspector/Common/DrsImportService.cs)
3. Update DialogService file filters to include the new extension (nvidiaProfileInspector/Services/DialogService.cs)
4. Add a test profile file in the new format to verify round-trip serialization

Add a new application resolver (e.g., Game Pass, GOG)

1. Create a new resolver class similar to SteamAppResolver or EpicAppResolver (nvidiaProfileInspector/Common/Helper/SteamAppResolver.cs)
2. Implement app enumeration and path resolution logic (nvidiaProfileInspector/Common/Helper/SteamAppResolver.cs)
3. Register the resolver in AppBootstrapper's IoC container setup (nvidiaProfileInspector/AppBootstrapper.cs)
4. Wire the resolver into the UI's app picker dialog or auto-detection service

Add a new UI control or settings panel

1. Create a new WPF UserControl in the UI/Controls folder (nvidiaProfileInspector/UI/Controls/SearchableComboBox.cs)
2. Add XAML layout and code-behind for the control (nvidiaProfileInspector/UI/Styles/Common.xaml)
3. If needed, create a data-binding converter in UI/Converters (nvidiaProfileInspector/UI/Converters/Converters.cs)
4. Register the control's style in an appropriate resource dictionary (Common.xaml, etc.)

• NVIDIA NVAPI DRS (Driver Settings API) — Direct access to driver profile database; only official API for reading/writing per-app profiles without registry manipulation
• WPF (Windows Presentation Foundation — undefined

Admin elevation required: The app checks AdminHelper.cs and must run elevated to write profiles; launching without admin silently limits functionality. NVAPI versioning: NVIDIA drivers expose NVAPI via DLLs; incompatible driver versions may cause NVAPI calls to fail—no graceful fallback visible. Encrypted settings: DrsDecrypterService handles decryption; keys are driver-version-dependent; if decryption logic diverges from driver, values will read as garbage. .NET Framework 4.8 EOL: No path visible to .NET 6+ (Framework EOL 2026); modernization blocked by WPF + XAML architecture and NVAPI interop assumptions. Profile file format brittleness: Custom import/export in Common/Import/ assumes specific XML structure; malformed .nip files will crash parser (no schema validation visible). Single-threaded UI: No async patterns visible; long NVAPI calls (scanning profiles) will freeze UI if not backgrounded—verify UI responsiveness during profile load.

• NVAPI (NVIDIA Driver Settings API) — The entire application is a wrapper around NVAPI function calls; understanding NVAPI's session/scope model, setting hierarchy (global vs per-app), and encrypted value encoding is essential to debug profile read/write failures or add new setting types.
• Bitmask-encoded settings — Profile Inspector includes a Bit Editor tool for editing bitmask-style settings (visible in highlights); many NVIDIA driver settings are bit-packed integers where each bit is a flag; understanding bit manipulation is needed to correctly serialize/deserialize these settings in ImportExportUtil.cs.
• Driver profile database encryption — DrsDecrypterService.cs handles decryption of sensitive driver settings; the driver stores some values encrypted; any changes to driver encryption schemes will require updates to the decryption logic, making this a fragile integration point.
• WPF data binding and XAML — The UI is built with WPF and XAML (App.xaml); understanding two-way binding, dependency properties, and XAML namespace resolution is required to add new UI panels, settings views, or fix binding bugs.
• Dependency Injection (AppBootstrapper pattern) — AppBootstrapper.cs registers and wires services; adding new features (e.g., new profile import format) requires understanding the DI container setup and service lifetime management.
• Metadata abstraction patterns (ISettingMetaService) — Common/Meta/ defines multiple metadata sources (Constant, Driver, Scanned, Custom); the abstraction allows pluggable metadata providers; understanding this pattern is needed to add support for new NVIDIA setting types or driver versions without modifying core logic.
• SLI (Scalable Link Interface) and Optimus GPU switching — The README highlights SLI settings and Optimus behavior as features; these are NVIDIA multi-GPU and integrated/discrete GPU switching technologies; understanding their profile switches is needed to debug or document GPU configuration features.

• keylase/NVIDIA-Web-Control — Web-based NVIDIA GPU control alternative; solves similar profile-editing problem but browser-based rather than desktop WPF, useful comparison for architecture decisions.
• tpill90/battlenet-manager — Game launcher integration utility also targeting Windows gamers with advanced settings; shares target audience and registry/driver manipulation concerns.
• GPUOpen-Tools/RGP — AMD's GPU Profiler; companion repo showing how AMD exposes low-level GPU profile controls, useful for understanding cross-vendor GPU profiling patterns.
• GameTechDev/nvml — NVIDIA Management Library samples and documentation; direct upstream reference for NVAPI concepts and driver communication patterns used in Profile Inspector.
• SteamDatabase/SteamAppIDs — Steam app ID database; Profile Inspector's SteamAppResolver.cs likely consumes this or similar for matching Steam games to GPU profiles.

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add unit tests for DrsSettingsService and DrsDecrypterService classes

The core DRS (Driver Settings) service classes in Common/ lack unit test coverage. These services handle critical functionality like settings encryption/decryption and profile management. Adding tests for DrsDecrypterService.cs, DrsSettingsService.cs, and DrsSettingsServiceBase.cs would improve reliability and make refactoring safer. This is especially important given the registry/driver interaction these services perform.

• [ ] Create nvidiaProfileInspector.Tests project with xUnit/NUnit framework
• [ ] Add unit tests for DrsDecrypterService.cs covering encryption/decryption logic
• [ ] Add unit tests for DrsSettingsService.cs mocking NVAPI calls
• [ ] Add unit tests for ImportExportUtil.cs profile import/export scenarios
• [ ] Verify tests run in release.yml workflow

Refactor and modularize Large Native/NVAPI/NvApiDriverSettings.cs wrapper

The NvApiDriverSettings.cs file is auto-generated from NvApiDriverSettings.tt template and likely contains hundreds of settings definitions. This large monolithic file should be split into logical modules (e.g., GraphicsSettings.cs, PerformanceSettings.cs, CompatibilitySettings.cs) for better maintainability. Additionally, the template-based generation should be documented with a README in Native/NVAPI/ explaining the code generation process.

• [ ] Create Native/NVAPI/README.md documenting the .tt template and generation process
• [ ] Analyze NvApiDriverSettings.cs to identify logical groupings of settings
• [ ] Create partial classes or separate files for each setting category (graphics, performance, compatibility, etc.)
• [ ] Update code generation template to produce modular output or add post-generation splitting script
• [ ] Verify NvapiDrsWrapper.cs and NvapiDrsWrapper.Mock.cs still reference settings correctly

Add integration tests for profile import/export with Common/Import classes

The Import namespace contains critical profile serialization logic (Profile.cs, ProfileSetting.cs, Profiles.cs, SettingValueType.cs, ImportExportUtil.cs) but lacks visible test coverage. End-to-end tests validating profile round-trip (export → import) with various setting types, edge cases, and compatibility scenarios would prevent regressions and document expected behavior.

• [ ] Create integration test fixture that loads sample .nip profile files
• [ ] Add tests for Profiles.cs deserialization with various XML formats
• [ ] Add tests for ProfileSetting.cs with all SettingValueType enum values (Integer, Binary, String, etc.)
• [ ] Add tests for ImportExportUtil.cs round-trip scenarios (export profile → modify XML → re-import)
• [ ] Add test for backward compatibility with older profile formats if applicable
• [ ] Store test fixture files in nvidiaProfileInspector.Tests/Resources/profiles/

• Add unit tests for DrsDecrypterService: The decryption logic in Common/DrsDecrypterService.cs handles sensitive setting values but no test directory is visible; write tests for decrypt/encrypt round-trips with sample driver data to catch version-skew bugs early.
• Document NVAPI interop layer: The NVAPI C interop calls are likely in unlisted .cs files or P/Invoke declarations; create a markdown guide explaining which NVAPI functions map to which driver profile operations, required for anyone modifying profile reading/writing logic.
• Add telemetry or logging for profile import failures: Common/Import/ImportExportUtil.cs loads .nip and text-format profiles but likely has sparse error handling; add structured logging/error reporting when import fails (malformed XML, incompatible setting names, missing apps) so users can diagnose why their exported profile won't re-import.

• Medium · Native P/Invoke Calls Without Validation — nvidiaProfileInspector/Native/WINAPI/SafeNativeMethods.cs, nvidiaProfileInspector/Native/NVAPI/NvapiDrsWrapper.cs. The codebase contains multiple Native/WINAPI and NVAPI P/Invoke calls that interact with unmanaged code. Files like SafeNativeMethods.cs, NvapiDrsWrapper.cs, and ShellLink.cs make direct calls to native Windows APIs. Without proper input validation and error handling, these could lead to memory corruption or elevation of privilege attacks. Fix: Implement comprehensive input validation for all P/Invoke parameters, use SafeHandle wrappers for pointers, validate return values from all native calls, and implement exception handling for native interop failures.
• Medium · Registry Access Without Permission Verification — nvidiaProfileInspector/Common/DrsSettingsService.cs, nvidiaProfileInspector/Common/Helper/AdminHelper.cs. The DrsSettingsService and related classes directly interact with NVIDIA driver settings registry/database. There is no apparent verification that the current user has administrative privileges before attempting these operations, though AdminHelper.cs exists. If privilege checks are incomplete, this could allow unauthorized modification of driver settings. Fix: Ensure all registry/settings modifications are preceded by explicit admin privilege verification. Review AdminHelper.cs to confirm it properly checks UAC elevation status and implement mandatory access control checks before any system-level changes.
• Medium · XML Deserialization Without Schema Validation — nvidiaProfileInspector/Common/Helper/XMLHelper.cs, nvidiaProfileInspector/Common/Import/ImportExportUitl.cs. The XMLHelper.cs file handles XML parsing for import/export functionality. XML deserialization can be vulnerable to XXE (XML External Entity) attacks and entity expansion attacks if not properly configured with secure parsing settings. Fix: Configure XmlDocument and XmlReader with secure settings: disable DTD processing, disable external entity resolution, disable inline schema processing. Use XmlReaderSettings with ProhibitDtd=true and XmlResolver=null.
• Low · Temporary Files Without Secure Deletion — nvidiaProfileInspector/Common/Helper/TempFile.cs. The TempFile.cs helper creates temporary files but may not securely overwrite sensitive data before deletion. Driver profiles may contain system configuration information. Fix: Implement secure file deletion by overwriting temporary file contents with random data before deletion. Use File.WriteAllBytes() with random bytes before File.Delete().
• Low · Unencrypted Cached Settings Storage — nvidiaProfileInspector/Common/Cache/CachedSettings.cs, nvidiaProfileInspector/Common/Helper/UserSettings.cs. The CachedSettings.cs and UserSettings.cs classes cache application and user settings. If sensitive driver configuration is cached, it may be stored unencrypted on disk. Fix: Review what data is cached and implement encryption for sensitive cached values. Use DPAPI (Data Protection API) for encrypting cached settings on Windows.
• Low · Missing Update Signature Verification — nvidiaProfileInspector/Common/Updates/AppUpdateService.cs, nvidiaProfileInspector/Common/Updates/GitHubReleaseClient.cs. The AppUpdateService.cs and GitHubReleaseClient.cs handle downloading updates from GitHub. Without proper signature verification, this could be vulnerable to MITM attacks or compromised release assets. Fix: Implement cryptographic signature verification for downloaded updates using code signing certificates. Verify SHA256 hashes of release assets and validate GPG signatures if available.
• Low · No Certificate Pinning for GitHub API Calls — nvidiaProfileInspector/Common/Updates/GitHubReleaseClient.cs. GitHubReleaseClient.cs makes HTTPS requests to GitHub API without certificate pinning, making it vulnerable to compromised CAs or MITM attacks. Fix: Implement certificate pinning for GitHub API requests. Alternatively, validate the certificate thumbprint of GitHub's certificates.
• Low · Potential Path Traversal in File Operations — undefined. Various helper classes (SteamAppResolver. Fix: undefined

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.