# How to Control Logitech Mouse DPI Settings with OpenLogi

> Control Logitech mouse DPI settings with OpenLogi. This open-source tool uses HID++ to adjust DPI on legacy and modern Logitech mice for precise control. Learn how today!

- Repository: [Xuan Zhang/OpenLogi](https://github.com/AprilNEA/OpenLogi)
- Tags: how-to-guide
- Published: 2026-08-25

---

**Yes, OpenLogi provides complete control over Logitech mouse DPI settings through its HID++ driver, supporting both legacy and modern mice via the AdjustableDpi and ExtendedAdjustableDpi features.**

OpenLogi is an open-source alternative to Logitech Options that enables full DPI management for compatible HID++ mice. By abstracting the low-level protocol differences between device generations, the project exposes a unified API for reading, writing, and persisting DPI configurations across CLI, GUI, and programmatic interfaces.

## Understanding OpenLogi's DPI Architecture

The **HID++ driver** (`openlogi-device`) automatically discovers the mouse's DPI capabilities by querying feature IDs `0x2201` (**AdjustableDpi**) or `0x2202` (**ExtendedAdjustableDpi**). This transparent detection ensures OpenLogi works with older Logitech hardware that exposes only the legacy feature, as well as newer models requiring the extended protocol.

The architecture routes DPI commands through a layered stack:

```

UI/CLI → IPC (openlogi-agent) → SharedChannel → hidpp::Device → DpiFeature::set_dpi()

```

This design decouples the user interface from hardware-specific implementation details, allowing the same `set_dpi` call to function regardless of whether the underlying device uses `0x2201` or `0x2202`.

## Core DPI Operations

OpenLogi exposes three high-level operations implemented in [`crates/openlogi-device/src/write/dpi.rs`](https://github.com/AprilNEA/OpenLogi/blob/main/crates/openlogi-device/src/write/dpi.rs):

- **`openlogi_hid::get_dpi(&route)`** – Returns the current active DPI value
- **`openlogi_hid::get_dpi_info(&route)`** – Retrieves the full capability list including supported DPI steps
- **`openlogi_hid::set_dpi(&route, dpi)`** – Writes a new DPI value to the device firmware

### Reading Current DPI and Capabilities

Before modifying settings, applications should query the device's capabilities to determine valid DPI ranges. The driver returns a structured response containing both the current setting and an iterator of supported values.

### Writing New DPI Values

When `set_dpi` is invoked, the driver selects the appropriate HID++ feature ID internally. The implementation includes **read-back verification** (lines 1000–1010 of [`dpi.rs`](https://github.com/AprilNEA/OpenLogi/blob/main/dpi.rs)) to confirm the firmware accepted the value, reporting a mismatch if the device rejects the requested DPI.

## Accessing DPI Controls Through OpenLogi

OpenLogi provides three primary interfaces for DPI management, each suited to different workflows.

### Command-Line Interface

The CLI offers immediate, scriptable control via the `openlogi diag dpi` command implemented in [`crates/openlogi-cli/src/cmd/diag/dpi.rs`](https://github.com/AprilNEA/OpenLogi/blob/main/crates/openlogi-cli/src/cmd/diag/dpi.rs). This performs a round-trip test: reading capabilities, writing a test DPI, verifying the result, and restoring the original value.

```bash

# Run automated DPI diagnostics with auto-selected target

openlogi diag dpi

# Explicitly set DPI to 1200

openlogi diag dpi --target 1200

```

### Agent IPC and GUI Integration

For desktop environments, the **OpenLogi Agent** exposes DPI controls through IPC. The agent's RPC handler in [`crates/openlogi-agent/src/server.rs`](https://github.com/AprilNEA/OpenLogi/blob/main/crates/openlogi-agent/src/server.rs) accepts `set_dpi` requests from the GUI or third-party clients, forwarding them to the HID driver via a `SharedChannel`.

The desktop UI ([`crates/openlogi-desktop/src/services/ipc.rs`](https://github.com/AprilNEA/OpenLogi/blob/main/crates/openlogi-desktop/src/services/ipc.rs)) invokes this RPC when users adjust settings in the Settings panel, ensuring real-time synchronization between the interface and hardware.

### Persistent Configuration

Users can persist DPI presets or concrete values in OpenLogi's TOML configuration. The `Config` struct in [`crates/openlogi-core/src/config.rs`](https://github.com/AprilNEA/OpenLogi/blob/main/crates/openlogi-core/src/config.rs) provides two key methods:

- **`Config::set_dpi`** – Stores a single DPI value that the agent reapplies on device reconnect
- **`Config::set_dpi_presets`** – Stores a vector of preset values for cycling via hardware buttons or UI selection

## Implementation Details in the Source Code

The DPI implementation spans several crates with distinct responsibilities:

- **[`crates/openlogi-device/src/write/dpi.rs`](https://github.com/AprilNEA/OpenLogi/blob/main/crates/openlogi-device/src/write/dpi.rs)** – Contains the core driver logic that abstracts over both `AdjustableDpi` and `ExtendedAdjustableDpi` features, handling protocol-specific packet construction
- **[`crates/openlogi-cli/src/cmd/diag/dpi.rs`](https://github.com/AprilNEA/OpenLogi/blob/main/crates/openlogi-cli/src/cmd/diag/dpi.rs)** – Implements the diagnostic command that tests the full read-write-verify cycle
- **[`crates/openlogi-agent/src/server.rs`](https://github.com/AprilNEA/OpenLogi/blob/main/crates/openlogi-agent/src/server.rs)** – Hosts the RPC handler that bridges IPC requests to driver calls
- **[`crates/openlogi-core/src/config.rs`](https://github.com/AprilNEA/OpenLogi/blob/main/crates/openlogi-core/src/config.rs)** – Manages serialization of DPI settings to the configuration file

The driver automatically negotiates with the firmware to determine whether to use feature `0x2201` or `0x2202`, eliminating the need for user-side compatibility checks.

## Practical Code Examples

### Programmatic DPI Control

```rust
use openlogi_hid::{self, Dpi};

// 1. Obtain a device route from the inventory
let route = /* DeviceRoute obtained from discovery */;

// 2. Query current DPI and supported values
let info = openlogi_hid::get_dpi_info(&route).await?;
println!("Current DPI: {}", info.current);
println!("Supported values: {:?}", info.capabilities.values());

// 3. Set a new DPI (must be in the supported list)
let new_dpi = Dpi::new(1600);
openlogi_hid::set_dpi(&route, new_dpi).await?;

// 4. Verify the write succeeded
let after = openlogi_hid::get_dpi(&route).await?;
assert_eq!(after, new_dpi);

```

### Persistent DPI Presets

```rust
use openlogi_core::hid::Dpi;
use openlogi_core::config::Config;

let mut cfg = Config::default();
let device_key = "receiver:abcd1234:slot:1"; // Stable device identifier

// Store multiple presets for hardware button cycling
cfg.set_dpi_presets(device_key, vec![
    Dpi::new(800),
    Dpi::new(1600),
    Dpi::new(2400)
]);

// Or set a default value for automatic reapplication
cfg.set_dpi(device_key, Dpi::new(1600));

```

## Summary

- OpenLogi controls Logitech mouse DPI settings through a unified abstraction over HID++ features `0x2201` and `0x2202`.
- The driver implements read, write, and capability discovery operations in [`crates/openlogi-device/src/write/dpi.rs`](https://github.com/AprilNEA/OpenLogi/blob/main/crates/openlogi-device/src/write/dpi.rs).
- Users can adjust DPI via CLI diagnostics, Agent IPC for GUI integration, or persistent TOML configuration.
- Automatic feature detection ensures compatibility with both legacy and modern Logitech mice without manual protocol selection.
- Built-in read-back verification confirms that firmware accepts DPI changes before reporting success.

## Frequently Asked Questions

### Does OpenLogi support all Logitech mice?

OpenLogi supports Logitech mice that implement the HID++ protocol and expose either the `AdjustableDpi` (0x2201) or `ExtendedAdjustableDpi` (0x2202) feature. Most modern Logitech gaming and productivity mice include these features, though basic HID-only devices without HID++ support are not compatible.

### What is the difference between AdjustableDpi and ExtendedAdjustableDpi?

**AdjustableDpi** (feature `0x2201`) is the legacy protocol used in older mice, while **ExtendedAdjustableDpi** (feature `0x2202`) supports higher precision settings and additional capabilities in newer hardware. OpenLogi's driver in [`dpi.rs`](https://github.com/AprilNEA/OpenLogi/blob/main/dpi.rs) transparently handles both protocols, presenting an identical API regardless of which feature the mouse exposes.

### Can I set DPI presets that persist across reboots?

Yes. Use the `Config::set_dpi_presets` method to store a list of DPI values in the OpenLogi configuration file. The agent automatically reapplies these settings when the mouse reconnects, ensuring consistent behavior across system restarts without requiring manual intervention through the CLI or GUI.

### How does OpenLogi verify that DPI changes were applied successfully?

After writing a new DPI value via `set_dpi`, the driver performs a read-back operation to confirm the firmware reports the same value. If the read-back differs from the requested setting (indicating the firmware rejected the value or rounded it), OpenLogi reports a mismatch error rather than falsely confirming success.