# cmpunlocker: unlocking the NVIDIA CMP 170HX for Linux compute

> cmpunlocker patches the nvidia-open kernel modules so a CMP 170HX reports its full SM throughput, memory geometry and BAR1 size. It is a Linux-only, root-only tool for one specific mining card, and it assumes you already run nvidia-open 610.xx.xx or newer.

**amoghmunikote/cmpunlocker** — A tool to unlobotomize your NVIDIA card!

- Repository: https://github.com/amoghmunikote/cmpunlocker
- Website: https://github.com/amoghmunikote/cmpunlocker
- Stars: 686 · Forks: 246
- Language: Shell
- License: GPL-2.0
- Published: 2026-09-17 · Updated: 2026-09-17 · Language: en
- Canonical page: https://hysenlabs.com/projects/amoghmunikote-cmpunlocker

## What cmpunlocker changes on a CMP 170HX

The CMP 170HX is a mining card whose firmware and OTP configuration restrict features that the silicon itself supports. cmpunlocker's stated purpose is to restore those features. According to the README, the unlock covers full SM compute throughput (SS0/SS1), memory geometry (64GB on 8GB cards, 40GB on 10GB cards), PCIe Gen 2 speeds, full BAR1 size of 64GB, JTAG host register access, VFIO-based passthrough, GPU profiling, and persistence across reboot through patched modules.

The audience is narrow and technical: someone who bought the card cheaply and wants to use it for compute work on Linux. The README's own framing points at this, and the project has been covered by outlets including Tom's Hardware and wccftech. That coverage is about the idea, not about whether your specific card and driver combination will work. The repository is a Shell project under GPL-2.0, with install.sh, remove.sh and verify.sh at the top level alongside driver/, common/, systemd/, tools/ and tests/ directories.

## How the patched nvidia-open modules are built

cmpunlocker does not ship a prebuilt binary blob. The install script downloads matching stock open-gpu-kernel-modules sources on first install, which is why the README lists network access as a requirement. That source tree is then modified and built against the kernel headers for the running kernel, and the resulting modules are installed in place of the stock nvidia-open ones. Because the modules are patched, they are unsigned, which is the reason Secure Boot must be disabled.

Python 3 is a build-time dependency, used to select the 8GB or 10GB geometry. That tells you the two card variants differ in how the memory configuration is derived, not merely in a runtime flag. The repository layout supports this reading: driver/ holds the module work, common/ holds shared logic, and tools/ holds supporting utilities. A systemd/ directory exists, which suggests some part of the flow is managed as a unit, though the README does not describe what that unit does.

There is no documented rollback path inside the install flow itself. Removal is a separate script, and the README says a reboot follows both install and remove.

## Installing cmpunlocker and picking the right memory profile

The README assumes you are in the repository root with the scripts present. Run the installer as root:

```bash
sudo ./install.sh
```

If the card variant is ambiguous, or you want to be explicit, pass --profile. The README gives both values and what each one produces:

```bash
sudo ./install.sh --profile=8gb    # 8GB card → 64GB unlock
sudo ./install.sh --profile=10gb   # 10GB card → 40GB unlock
```

After the script finishes, reboot. The README states that persistence across reboot works because the modules themselves are patched, so the unlock should survive without re-running anything. To undo it:

```bash
sudo ./remove.sh --yes
```

Then reboot again. The repository also contains verify.sh, which is not described in the README; if you want to confirm the unlock took effect, that is the file to read before running it, since the README does not document its output.

## Secure Boot, kernel headers and the failure modes that follow

The requirements list is short, and every item on it is a hard gate rather than a suggestion. Linux x86-64, root access, an actual CMP 170HX, nvidia-open 610.xx.xx or newer already installed with libraries and firmware, kernel headers matching the running kernel, Secure Boot disabled, network access on first install, and Python 3. Miss any one and the install either fails or produces modules the kernel refuses to load.

The kernel headers requirement is the one most likely to bite. If you upgrade your kernel through your distribution's normal package flow, the headers package for the new kernel may be installed while the patched modules were built for the old one. The README does not describe a DKMS-style rebuild hook, so the safe assumption is that a kernel upgrade requires re-running install.sh. That is a real ongoing cost, not a one-time setup step.

This is also the wrong tool in several clear cases. It is not for Windows, regardless of what people search for. It is not for other CMP cards; the README names the 170HX specifically, and the related searches around the CMP 90HX are a different card with a different configuration. It is not appropriate for a machine you cannot afford to have fail to boot, because unsigned replacement modules plus a Secure Boot requirement is a combination that can leave you at a recovery prompt. And it is not a supported configuration in any vendor sense: you are running modified kernel modules against a card whose restrictions were deliberate.

## cmpunlocker versus running the card as shipped

The alternative is not another unlock tool. It is running the CMP 170HX with the stock nvidia-open driver and accepting the restrictions: reduced SM throughput, the firmware-reported memory geometry, and the smaller BAR1 window. That path costs nothing, keeps Secure Boot enabled, survives kernel upgrades without intervention, and stays inside whatever support boundary your distribution and NVIDIA provide.

The difference in approach is where the change happens. cmpunlocker modifies the kernel module source and rebuilds it, so the card behaves differently at the driver level for every consumer of the device, including CUDA, OpenCL and any VFIO passthrough setup. A stock install changes nothing and simply reports what the firmware allows. If your workload fits inside the restricted geometry and throughput, the stock driver is the lower-risk choice. If it does not, cmpunlocker is the only mechanism described in this repository for changing that, and you take on the rebuild and reboot cycle as part of the deal.

## Maintenance, licensing and what to check before you commit

The last push to the default branch was on 2026-09-13, and v0.4 was released the same day, following v0.3 on 2026-08-30 and v0.2 on 2026-07-29. The repository is not archived. That release cadence is recent enough that the project is moving, but the README does not state a support window, a compatibility matrix beyond the 610.xx.xx minimum, or a policy for what happens when NVIDIA changes the open-gpu-kernel-modules source layout that install.sh downloads against. That last point is the structural risk: the tool depends on matching upstream sources, and nothing in the README says how that match is verified.

cmpunlocker is GPL-2.0. The patched modules are derived from open-gpu-kernel-modules, which is itself distributed under open licenses, so the source-availability side is consistent with that. What the licence does not settle is the warranty question: GPL-2.0 ships with no warranty, and you are replacing working kernel modules with modified ones. That is a statement about the licence text, not legal advice; if you are deploying this in any commercial setting, the licence and the hardware situation are both worth a conversation with someone qualified.

The upgrade cost is the practical one. Budget for re-running install.sh after kernel updates, for keeping linux-headers-$(uname -r) or kernel-devel current, and for a machine where Secure Boot stays off. Check the repository's tests/ and verify.sh before trusting the install on a card you depend on.

## Conclusion

cmpunlocker is for people who already own a CMP 170HX, run Linux x86-64 with nvidia-open 610.xx.xx or newer, and accept unsigned kernel modules on a machine with Secure Boot disabled. It is not for Windows users, not for other CMP models such as the 90HX, and not for anyone who needs a signed, vendor-supported driver stack. Verify three things before installing: that uname -r matches an installed linux-headers package, that your card is the 8GB or 10GB 170HX variant so the --profile value is correct, and that you have a way to boot a previous kernel or reinstall the stock modules if the patched ones fail to load.

## FAQ

### What is the NVIDIA CMP 170HX that cmpunlocker targets?

It is the specific NVIDIA card cmpunlocker supports, and the README lists it as a hard requirement alongside Linux x86-64 and root access. The tool restores features that its firmware and OTP configuration restrict.

### Does cmpunlocker work on Windows?

No. The README lists Linux (x86-64) as the first requirement, and the install and removal steps are shell scripts run with sudo. There is no Windows path documented in the repository.

### Which memory profile should I pass to cmpunlocker, 8gb or 10gb?

It depends on which CMP 170HX variant you have. The README states that --profile=8gb produces a 64GB unlock on 8GB cards, and --profile=10gb produces a 40GB unlock on 10GB cards.

### Can I run cmpunlocker with Secure Boot enabled?

No. The README requires Secure Boot to be disabled because the patched modules are unsigned. Leaving it on means the kernel will not load them.

### How do I remove cmpunlocker?

Run sudo ./remove.sh --yes from the repository and then reboot, as the README describes. The README does not document a rollback that avoids a reboot.

## Sources

- [amoghmunikote/cmpunlocker on GitHub](https://github.com/amoghmunikote/cmpunlocker)
- [License: GPL-2.0](https://github.com/amoghmunikote/cmpunlocker/blob/master/LICENSE)
- [Project website](https://github.com/amoghmunikote/cmpunlocker)
- [README](https://github.com/amoghmunikote/cmpunlocker/blob/master/README.md)
- [Releases](https://github.com/amoghmunikote/cmpunlocker/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/amoghmunikote-cmpunlocker