# Custom Fingerprint Flags for GPU Vendor and Renderer Spoofing in CloakBrowser

> Learn how to use custom fingerprint flags in CloakBrowser to spoof GPU vendor and renderer for targeted hardware profiles and enhanced privacy.

- Repository: [CloakHQ/CloakBrowser](https://github.com/CloakHQ/CloakBrowser)
- Tags: how-to-guide
- Published: 2026-05-09

---

**CloakBrowser supports `--fingerprint-gpu-vendor` and `--fingerprint-gpu-renderer` CLI flags that inject custom strings into the WebGL `UNMASKED_VENDOR_WEBGL` and `UNMASKED_RENDERER_WEBGL` properties, allowing you to override automatic GPU fingerprint generation with specific hardware profiles.**

CloakBrowser, developed by CloakHQ/CloakBrowser, provides a fingerprint subsystem for manipulating browser telemetry. By using custom fingerprint flags for GPU vendor and renderer spoofing, you can hardcode specific graphics card identities rather than accepting the auto-generated values derived from your fingerprint seed and selected platform.

## How GPU Fingerprint Flags Control WebGL Reporting

CloakBrowser exposes two specific CLI flags that target the WebGL debug renderer info extension:

- **`--fingerprint-gpu-vendor`** – Overrides the string returned by `WEBGL_debug_renderer_info.UNMASKED_VENDOR_WEBGL` (e.g., **"Intel Inc."**). By default, this value is auto-generated from the fingerprint seed combined with the selected platform.
- **`--fingerprint-gpu-renderer`** – Overrides the string returned by `WEBGL_debug_renderer_info.UNMASKED_RENDERER_WEBGL` (e.g., **"Intel Iris OpenGL Engine"**). Without these flags, the system automatically derives this from the seed and platform configuration.

According to the documentation in [`README.md`](https://github.com/CloakHQ/CloakBrowser/blob/main/README.md) (lines 615–617), these flags appear in the "Additional Flags" table as explicit overrides for graphics hardware identification.

## Implementation in the Argument Builder

The underlying logic resides in [`js/src/args.ts`](https://github.com/CloakHQ/CloakBrowser/blob/main/js/src/args.ts) (lines 15–40), where CloakBrowser constructs the final argument list passed to the Chromium process. The helper function collects user-supplied `args` and merges them with default stealth arguments. Because `--fingerprint-gpu-vendor` and `--fingerprint-gpu-renderer` are not part of the internal default set, the builder copies them unchanged into the final command-line invocation.

This architecture ensures that when you call `launch()` with custom GPU flags, the values pass directly to the Chromium runtime, which then patches the WebGL `UNMASKED_*` properties at the browser level. The implementation at [`js/src/args.ts`](https://github.com/CloakHQ/CloakBrowser/blob/main/js/src/args.ts) preserves these overrides without interference from the default stealth configuration.

## Usage Examples

You can supply these flags through both the Python and JavaScript/TypeScript APIs, or pass them directly to the CloakBrowser binary.

### Python API

```python
from cloakbrowser import launch

browser = launch(
    args=[
        "--fingerprint=42069",                              # deterministic seed

        "--fingerprint-gpu-vendor=Intel Inc.",             # custom vendor string

        "--fingerprint-gpu-renderer=Intel Iris OpenGL Engine",  # custom renderer string

    ]
)

```

### JavaScript/TypeScript API

```javascript
import { launch } from "cloakbrowser";

(async () => {
  const browser = await launch({
    args: [
      "--fingerprint=42069",
      "--fingerprint-gpu-vendor=Intel Inc.",
      "--fingerprint-gpu-renderer=Intel Iris OpenGL Engine",
    ],
  });
})();

```

### Command Line

When launching the CloakBrowser binary directly, append the flags as standard Chromium arguments:

```bash
./cloak-browser --fingerprint-gpu-vendor="NVIDIA Corporation" --fingerprint-gpu-renderer="NVIDIA GeForce GTX 1660/PCIe/SSE2"

```

## Compatibility with Seed-Based Fingerprinting

These custom fingerprint flags for GPU vendor and renderer spoofing operate independently of the automatic fingerprint generation system. You can combine them with `--fingerprint` (to maintain a deterministic seed), `--fingerprint-platform`, or `--fingerprint-noise=false` without conflict.

The test suite at [`js/tests/config.test.ts`](https://github.com/CloakHQ/CloakBrowser/blob/main/js/tests/config.test.ts) (lines 32–33) verifies that GPU fingerprint flags are excluded from the default build unless explicitly provided. This guarantees that specifying a custom vendor or renderer requires intentional user action and does not accidentally leak into standard stealth profiles.

## Key Source Files

| File | Function |
|------|----------|
| [`js/src/args.ts`](https://github.com/CloakHQ/CloakBrowser/blob/main/js/src/args.ts) | Merges user-supplied CLI flags with default stealth arguments; passes custom GPU fingerprint flags unchanged to the Chromium process. |
| [`README.md`](https://github.com/CloakHQ/CloakBrowser/blob/main/README.md) | Documents the GPU spoofing flags in the "Additional Flags" section. |
| [`js/tests/config.test.ts`](https://github.com/CloakHQ/CloakBrowser/blob/main/js/tests/config.test.ts) | Validates that GPU fingerprint flags remain absent from default configurations unless explicitly added. |

## Summary

- **Custom GPU Control**: Use `--fingerprint-gpu-vendor` and `--fingerprint-gpu-renderer` to hardcode WebGL vendor and renderer strings.
- **WebGL Targeting**: These flags specifically override `UNMASKED_VENDOR_WEBGL` and `UNMASKED_RENDERER_WEBGL` debug info.
- **Seamless Integration**: Pass the flags through the `args` parameter in `launch()`; they merge cleanly with existing fingerprint seeds and stealth defaults.
- **Source Location**: Implementation resides in [`js/src/args.ts`](https://github.com/CloakHQ/CloakBrowser/blob/main/js/src/args.ts), with documentation in [`README.md`](https://github.com/CloakHQ/CloakBrowser/blob/main/README.md) (lines 615–617).

## Frequently Asked Questions

### What WebGL properties do these flags control?

The `--fingerprint-gpu-vendor` flag controls the `UNMASKED_VENDOR_WEBGL` property returned by the `WEBGL_debug_renderer_info` extension, while `--fingerprint-gpu-renderer` controls `UNMASKED_RENDERER_WEBGL`. These properties typically expose the actual graphics hardware to JavaScript, but CloakBrowser intercepts and replaces them with your custom values.

### Where are these flags documented in the repository?

The flags are documented in the "Additional Flags" table within [`README.md`](https://github.com/CloakHQ/CloakBrowser/blob/main/README.md) at lines 615–617. The documentation specifies that these arguments override the automatic GPU fingerprint generation that normally derives values from the seed and platform selection.

### Can I use these flags alongside automatic fingerprint generation?

Yes. The GPU vendor and renderer flags function as overrides that work independently of the automatic system. You can combine `--fingerprint=SEED` with `--fingerprint-gpu-vendor` to maintain a deterministic fingerprint for all other browser properties while forcing a specific GPU identity.

### How does CloakBrowser process these CLI arguments?

The `launch()` function in [`js/src/args.ts`](https://github.com/CloakHQ/CloakBrowser/blob/main/js/src/args.ts) (lines 15–40) collects all user-supplied arguments and merges them with default stealth settings. Since GPU fingerprint flags are not part of the internal defaults, they pass through unchanged to the Chromium process, which then applies the spoofing to WebGL queries.