# Does OpenLogi Collect Telemetry Data? A Deep Dive into the Local-First Architecture

> OpenLogi does not collect telemetry data. Discover how its local-first architecture ensures your privacy with account-free, plain-text configurations and zero network-based collection.

- Repository: [Xuan Zhang/OpenLogi](https://github.com/AprilNEA/OpenLogi)
- Tags: deep-dive
- Published: 2026-08-21

---

**OpenLogi does not collect telemetry data.** The application is explicitly designed as a local-first, account-free tool that stores all user configuration in plain-text TOML files without any analytics, usage reporting, or network-based data collection.

OpenLogi is an open-source input device management tool developed by AprilNEA that prioritizes user privacy through a严格 local-only architecture. Understanding whether OpenLogi collects telemetry data requires examining the source code directly, as the project makes specific architectural choices to eliminate any form of remote data transmission. This analysis reviews the actual implementation in the `AprilNEA/OpenLogi` repository to verify these privacy guarantees.

## Evidence from the OpenLogi Source Code

The OpenLogi codebase contains multiple explicit declarations and implementation details confirming the absence of telemetry systems. These assertions appear in documentation, packaging configurations, and core Rust modules.

### Project Documentation and Manifests

The foundational project documentation establishes the privacy-first philosophy immediately. In the top-level [`AGENTS.md`](https://github.com/AprilNEA/OpenLogi/blob/main/AGENTS.md) file, the project is described with the precise phrase **"no account, no telemetry, plain-TOML"** at line 5. This statement serves as the definitive architectural constraint for all development.

The Linux packaging configuration reinforces this commitment. Within [`packaging/linux/nfpm.yaml`](https://github.com/AprilNEA/OpenLogi/blob/main/packaging/linux/nfpm.yaml) at line 18, a comment explicitly marks the package as **"no telemetry"**, ensuring that distribution maintainers and users auditing the build process can verify the absence of analytics hooks in the installation pipeline.

### Core Configuration Implementation

The central configuration module implements the "no telemetry" guarantee at the code level. In [`crates/openlogi-core/src/config/settings.rs`](https://github.com/AprilNEA/OpenLogi/blob/main/crates/openlogi-core/src/config/settings.rs) at line 70, a comment references the README's promise of **"no telemetry, no auto-update poller"**, directly linking the configuration structure to the project's privacy commitments.

This module handles all user preferences—including button mappings, DPI presets, and device settings—using strictly local TOML file serialization. No telemetry flags, analytics IDs, or reporting endpoints exist in the configuration schema.

### Update Mechanism and Network Policy

The only feature capable of generating network traffic is the optional update checker, which is strictly opt-in. The Windows-specific implementation in [`crates/openlogi-desktop/src/windows/update_consent.rs`](https://github.com/AprilNEA/OpenLogi/blob/main/crates/openlogi-desktop/src/windows/update_consent.rs) (lines 3-108) clarifies that update checks are **off by default** and that any automatic download mechanism would enforce **"no automatic download or telemetry"**.

This implementation ensures that even when users enable version checking, the process involves only a simple HTTP request to check for newer releases, transmitting zero identifying information or usage statistics.

## How OpenLogi Handles User Data Locally

All user data processing occurs entirely on the local machine through plain-text configuration files. The application uses the TOML format for human-readable, auditable settings storage.

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

// Load the TOML configuration from the default location.
let cfg = Config::load_default().expect("Failed to read config");
println!("Current config: {:#?}", cfg);

```

This Rust code demonstrates the `Config::load_default()` method from the `openlogi-core` crate, which reads configuration from the local filesystem (typically `~/.config/openlogi/config.toml` on Linux or equivalent paths on Windows/macOS). The method signature returns a local struct containing device mappings and application settings, with no network-bound fields or telemetry structures.

## Verifying Telemetry-Free Operation

Users can independently verify that OpenLogi maintains zero network communication for analytics purposes by inspecting the configuration file and monitoring network traffic. The sole network-related setting controls update checking, which remains disabled by default.

To explicitly ensure no network connectivity occurs:

```toml

# In your OpenLogi TOML config (e.g., ~/.config/openlogi/config.toml)

[app_settings]

# Keep update checks turned off – this also guarantees no telemetry.

auto_update = false

```

Setting `auto_update = false` in the `[app_settings]` section prevents the application from contacting any remote servers. Combined with the absence of telemetry collection logic in the source code, this configuration guarantees a completely offline-capable operation for sensitive environments.

## Summary

- **OpenLogi explicitly prohibits telemetry** through documented architecture decisions in [`AGENTS.md`](https://github.com/AprilNEA/OpenLogi/blob/main/AGENTS.md) and [`nfpm.yaml`](https://github.com/AprilNEA/OpenLogi/blob/main/nfpm.yaml).
- **All configuration remains local** in plain-text TOML files managed by [`crates/openlogi-core/src/config/settings.rs`](https://github.com/AprilNEA/OpenLogi/blob/main/crates/openlogi-core/src/config/settings.rs).
- **Network activity is strictly optional** and limited to version checking only when `auto_update` is manually enabled in [`update_consent.rs`](https://github.com/AprilNEA/OpenLogi/blob/main/update_consent.rs).
- **No analytics infrastructure exists** in the codebase—no tracking IDs, no reporting endpoints, and no usage statistics collection.
- Users can audit the Rust source code to confirm zero telemetry implementation across all platforms.

## Frequently Asked Questions

### Does OpenLogi collect telemetry data?

No. According to the `AprilNEA/OpenLogi` source code, the application contains zero telemetry collection logic. The project documentation in [`AGENTS.md`](https://github.com/AprilNEA/OpenLogi/blob/main/AGENTS.md) explicitly states "no account, no telemetry, plain-TOML," and the implementation in [`crates/openlogi-core/src/config/settings.rs`](https://github.com/AprilNEA/OpenLogi/blob/main/crates/openlogi-core/src/config/settings.rs) maintains this guarantee by storing all data locally without network transmission.

### Where does OpenLogi store user configuration?

OpenLogi stores all user settings—including mouse button mappings, DPI configurations, and device profiles—in local plain-text TOML files. The `Config::load_default()` method in [`crates/openlogi-core/src/config/settings.rs`](https://github.com/AprilNEA/OpenLogi/blob/main/crates/openlogi-core/src/config/settings.rs) manages these files, typically located in the user's configuration directory (e.g., `~/.config/openlogi/` on Linux systems).

### Can OpenLogi connect to the internet?

OpenLogi can only connect to the internet if users manually enable the update checking feature. The [`crates/openlogi-desktop/src/windows/update_consent.rs`](https://github.com/AprilNEA/OpenLogi/blob/main/crates/openlogi-desktop/src/windows/update_consent.rs) module confirms that update checks are disabled by default, and even when enabled, these connections only check for software updates without transmitting telemetry or personal data. Setting `auto_update = false` in the TOML configuration ensures completely offline operation.

### Is OpenLogi truly account-free?

Yes. OpenLogi requires no user accounts, registration, or authentication. The project's architecture deliberately avoids cloud synchronization or user identification systems. This "account-free" design is documented in [`AGENTS.md`](https://github.com/AprilNEA/OpenLogi/blob/main/AGENTS.md) and implemented throughout the Rust codebase, ensuring that device management functions entirely through local configuration files without external dependencies.