# OpenLogi License and Telemetry: A Complete Guide to the Dual-License Model and Privacy-First Design

> Explore the OpenLogi license and telemetry options. Learn about its dual MIT/Apache-2.0 license and privacy-first, telemetry-free design. Get the facts.

- Repository: [Xuan Zhang/OpenLogi](https://github.com/AprilNEA/OpenLogi)
- Tags: best-practices
- Published: 2026-09-10

---

**OpenLogi is released under a dual MIT/Apache-2.0 license and is explicitly telemetry-free by default, with all usage data collection disabled out of the box.**

The AprilNEA/OpenLogi repository provides a privacy-focused logistics application with flexible licensing options and zero telemetry collection. Understanding the OpenLogi license and telemetry architecture is essential for organizations deploying this tool in security-sensitive environments. This guide examines the specific license files, configuration options, and source code mechanisms that govern legal usage and data privacy.

## Understanding the OpenLogi Dual-License Model

OpenLogi employs a dual-license strategy that allows users to choose between two permissive open-source licenses. This flexibility lets organizations select the legal framework that best aligns with their compliance requirements.

### MIT and Apache-2.0 License Files

The source code is available under either the MIT license or the Apache-2.0 license. You can find the complete legal text for both options in the repository root:

- **`LICENSE-MIT`** – Contains the standard MIT license text governing software usage, modification, and distribution
- **`LICENSE-APACHE`** – Contains the Apache License 2.0 text with its explicit patent grant provisions

When building OpenLogi from source, you can determine which license applies to your specific compilation using compile-time feature flags. The Rust source code uses conditional compilation to track this metadata:

```rust
// In any crate you can query the compile‑time feature flags.
#[cfg(feature = "apache")]
fn license() -> &'static str { "Apache‑2.0" }
#[cfg(not(feature = "apache"))]
fn license() -> &'static str { "MIT" }

println!("OpenLogi is compiled under the {} license.", license());

```

### Design Assets and Third-Party Licensing

Not all files in the repository fall under the dual-license model. The **`design/LICENSE`** file governs the logo and brand assets, which are copyright © 2026 AprilNEA and are **not** covered by the MIT/Apache licenses. Additionally, third-party code such as the vendored `hidpp` crate carries its own 0BSD license, as documented in the README's License section.

## Verifying OpenLogi Telemetry Settings

OpenLogi maintains a strict "no account, no telemetry" policy as defined in [`AGENTS.md`](https://github.com/AprilNEA/OpenLogi/blob/main/AGENTS.md). The application does not collect usage statistics, crash reports, or analytics data unless explicitly configured otherwise.

### Configuration-Based Telemetry Controls

The telemetry configuration resides in **[`crates/openlogi-core/src/config/settings.rs`](https://github.com/AprilNEA/OpenLogi/blob/main/crates/openlogi-core/src/config/settings.rs)**, where the `telemetry` flag defaults to `false`. Users can verify their current settings by reading the TOML configuration file typically located at `~/.config/openlogi/config.toml`:

```rust
use std::fs;
use toml::Value;

// OpenLogi stores its config in ~/.config/openlogi/config.toml
let cfg = fs::read_to_string(
    dirs::config_dir().unwrap().join("openlogi/config.toml")
).unwrap();
let toml: Value = cfg.parse().unwrap();

let telemetry_enabled = toml
    .get("app_settings")
    .and_then(|s| s.get("telemetry"))
    .and_then(Value::as_bool)
    .unwrap_or(false);

println!("Telemetry enabled? {}", telemetry_enabled);

```

### Runtime and Compile-Time Verification

Update checks represent the only network-accessing functionality related to telemetry, and these are disabled by default. The optional "auto-update poller" remains off unless users explicitly opt-in through the configuration. You can disable any telemetry-related features at runtime using the command-line interface:

```bash
openlogi --set app_settings.telemetry=false

```

## Checking License Compliance in Your Build

To ensure compliance when distributing OpenLogi derivatives, verify that you respect the separation between source code licenses and design assets. The source code permits modification and redistribution under your chosen license (MIT or Apache-2.0), while the `design/LICENSE` restrictions apply to the logo and branding elements.

When auditing your installation, confirm that:
1. The `LICENSE-MIT` or `LICENSE-APACHE` file accompanies your distribution
2. The `design/LICENSE` terms are respected for any included branding
3. Third-party crates like `hidpp` retain their original 0BSD license notices

## Summary

- **Dual-license flexibility**: OpenLogi offers both MIT and Apache-2.0 licenses for the source code, selectable at compile time via feature flags.
- **Separate asset licensing**: Logos and brand materials in `design/` fall under a distinct copyright license (© 2026 AprilNEA), distinct from the software licenses.
- **Zero telemetry by default**: The application collects no usage data, with the `telemetry` configuration flag in [`crates/openlogi-core/src/config/settings.rs`](https://github.com/AprilNEA/OpenLogi/blob/main/crates/openlogi-core/src/config/settings.rs) defaulting to `false`.
- **Update checking disabled**: Auto-update polling is opt-in only and remains disabled unless explicitly enabled in user configuration.
- **Third-party attribution**: Vendored dependencies like the `hidpp` crate maintain their own 0BSD licensing terms.

## Frequently Asked Questions

### Is OpenLogi really telemetry-free?

Yes. According to the [`AGENTS.md`](https://github.com/AprilNEA/OpenLogi/blob/main/AGENTS.md) file in the AprilNEA/OpenLogi repository, the project promises "no account, no telemetry" as a core design principle. The `telemetry` boolean flag in the configuration settings defaults to `false`, meaning the application does not transmit usage statistics, crash reports, or analytics data to any remote servers.

### Which license should I choose for my project?

Choose **MIT** if you prefer a short, simple license with minimal conditions. Choose **Apache-2.0** if you require explicit patent protection or need to satisfy corporate legal departments that prefer Apache's patent grant clause. Both licenses are permissive and allow commercial use, modification, and distribution.

### Are the OpenLogi logo and branding free to use?

No. While the source code is freely licensed, the logo and brand assets located in the `design/` directory are governed by a separate license file (`design/LICENSE`) and are copyright © 2026 AprilNEA. These assets are **not** covered by the MIT or Apache-2.0 licenses and require separate permission for use.

### How do I verify that telemetry is disabled in my installation?

Check your configuration file at `~/.config/openlogi/config.toml` for the `app_settings.telemetry` value, or query the setting programmatically using Rust's TOML parsing as shown in the code examples above. Additionally, verify that no update-check processes are running by ensuring the auto-update poller remains disabled in your settings.