# Which Telemetry Events Does Munder Difflin Collect and How to Opt Out

> Discover the five anonymous telemetry events Munder Difflin collects: first_run, app_launched, agent_spawned, feature_used, and session_ended. Learn how to easily opt out via settings, environment variables, or building from so...

- Repository: [Chaitanya Giri/munder-difflin](https://github.com/chaitanyagiri/munder-difflin)
- Tags: best-practices
- Published: 2026-08-20

---

**Munder Difflin collects only five anonymous telemetry events—`first_run`, `app_launched`, `agent_spawned`, `feature_used`, and `session_ended`—and users can disable them via the Settings UI, the `DO_NOT_TRACK` environment variable, or by building from source without a PostHog API key.**

Munder Difflin, an open-source agentic coding environment maintained by `chaitanyagiri/munder-difflin`, implements a privacy-first analytics system that never transmits personally identifying information. All telemetry events are strictly allow-listed in [`src/main/analytics.ts`](https://github.com/chaitanyagiri/munder-difflin/blob/main/src/main/analytics.ts) and documented in the project's [`TELEMETRY.md`](https://github.com/chaitanyagiri/munder-difflin/blob/main/TELEMETRY.md) contract. Understanding exactly what data leaves your machine and how to stop it ensures you maintain full control over your development workflow.

## What Telemetry Events Munder Difflin Collects

The application records a minimal set of **anonymous** usage events to gauge feature adoption and session patterns. Every event shares three standard properties—`app_version`, `os`, and `arch`—and contains no file paths, transcript content, API keys, or user identifiers.

### The Complete Event List

According to [`TELEMETRY.md`](https://github.com/chaitanyagiri/munder-difflin/blob/main/TELEMETRY.md), the analytics implementation tracks exactly five event types:

| Event | Extra Property | Emission Trigger |
|-------|----------------|------------------|
| `first_run` | — | Emitted once, the first time the application ever starts |
| `app_launched` | — | Emitted on every application startup |
| `agent_spawned` | `provider` (e.g., `claude`, `codex`) | Emitted when a new agent terminal spawns |
| `feature_used` | `feature` (e.g., `slack_trigger`, `voice_dictation`) | Emitted at most once per feature per session |
| `session_ended` | `duration_bucket` (`<5m`, `5-30m`, `30m-2h`, `2-8h`, `8h+`) | Emitted when the app quits, using coarse buckets |

The `session_ended` event specifically buckets raw durations into coarse ranges before transmission, ensuring precise session length remains local to your machine.

### How the Allow-List Enforces Privacy

In [`src/main/analytics.ts`](https://github.com/chaitanyagiri/munder-difflin/blob/main/src/main/analytics.ts), the analytics client implements a strict allow-list filter. Any event not explicitly defined in the contract is dropped before reaching the outbound service. This hard constraint prevents accidental leakage of debug logs or unintended metadata.

## How to Disable Munder Difflin Telemetry

The repository provides three independent opt-out mechanisms. Activating any one of them immediately disables all telemetry transmission.

### Method 1: Toggle the Settings UI Switch

The most accessible method uses the Settings modal. Navigate to **General > Anonymous usage stats** and toggle the switch to **off**.

This action writes `telemetryEnabled: false` to the user configuration managed by [`src/main/config.ts`](https://github.com/chaitanyagiri/munder-difflin/blob/main/src/main/config.ts). The renderer-side implementation in [`src/renderer/src/components/SettingsModal.tsx`](https://github.com/chaitanyagiri/munder-difflin/blob/main/src/renderer/src/components/SettingsModal.tsx) handles the state transition:

```tsx
// In SettingsModal.tsx – the toggle handler
const toggleTelemetry = async () => {
  const next = !telemetryOn;          // flip UI state
  setTelemetryOn(next);               // optimistic UI update
  try {
    await window.cth.updateConfig({ telemetryEnabled: next });
  } catch {
    // revert UI on failure
    setTelemetryOn(!next);
  }
};

```

### Method 2: Set the DO_NOT_TRACK Environment Variable

Before launching the application, set the `DO_NOT_TRACK` environment variable to any non-empty value other than `0`. The check occurs in [`src/main/analytics.ts`](https://github.com/chaitanyagiri/munder-difflin/blob/main/src/main/analytics.ts) before the app reads its configuration file:

```ts
function dntSet(): boolean {
  const v = process.env.DO_NOT_TRACK;
  return v !== undefined && v !== '' && v !== '0';
}
// All tracking calls return early when dntSet() === true

```

To apply this on macOS or Linux:

```bash
export DO_NOT_TRACK=1
./MunderDifflin.app

```

On Windows PowerShell:

```powershell
$env:DO_NOT_TRACK="1"
.\MunderDifflin.exe

```

### Method 3: Build From Source Without Analytics

The PostHog API key (`__POSTHOG_KEY__`) is injected at build time. Compiling the application without providing this key results in a no-op analytics module. To create a telemetry-free binary:

```bash

# Clone the repo and build without injecting a PostHog key

git clone https://github.com/chaitanyagiri/munder-difflin.git
cd munder-difflin

# Ensure POSTHOG_KEY is empty or unset

export POSTHOG_KEY=
npm run build

```

This method is ideal for enterprise deployments or privacy-sensitive environments requiring absolute assurance that no network calls to analytics endpoints can occur.

### Programmatic Disabling (Runtime)

For extension developers or power users, the main process exposes a direct API to toggle telemetry at runtime:

```ts
import { analytics } from './analytics';

// Turn telemetry off for the current runtime
analytics.setEnabled(false);

```

This is useful when scripting application behavior or building custom wrappers, though the change persists only for the current session unless paired with a configuration update.

## Summary

- **Five events only**: Munder Difflin sends `first_run`, `app_launched`, `agent_spawned`, `feature_used`, and `session_ended`, each stripped of PII and file paths.
- **Allow-listed enforcement**: [`src/main/analytics.ts`](https://github.com/chaitanyagiri/munder-difflin/blob/main/src/main/analytics.ts) drops any event not explicitly defined in [`TELEMETRY.md`](https://github.com/chaitanyagiri/munder-difflin/blob/main/TELEMETRY.md).
- **Three opt-out paths**: Disable via Settings UI (persists to [`src/main/config.ts`](https://github.com/chaitanyagiri/munder-difflin/blob/main/src/main/config.ts)), set `DO_NOT_TRACK=1`, or build from source without `POSTHOG_KEY`.
- **No fine-grained control**: Opting out disables the entire analytics pipeline; there is no mechanism to selectively allow specific events while blocking others.

## Frequently Asked Questions

### Does Munder Difflin collect personal information?

No. According to the source code in [`src/main/analytics.ts`](https://github.com/chaitanyagiri/munder-difflin/blob/main/src/main/analytics.ts) and the [`TELEMETRY.md`](https://github.com/chaitanyagiri/munder-difflin/blob/main/TELEMETRY.md) contract, events contain only `app_version`, `os`, `arch`, and event-specific enums or coarse duration buckets. The system explicitly excludes usernames, repository paths, API keys, and code content from transmission.

### Can I verify that telemetry is actually disabled?

Yes. If you use the `DO_NOT_TRACK` environment variable, the `dntSet()` function in [`src/main/analytics.ts`](https://github.com/chaitanyagiri/munder-difflin/blob/main/src/main/analytics.ts) returns `true` and blocks all tracking calls before they execute. When building from source without `POSTHOG_KEY`, the analytics module compiles to a no-op, ensuring no outbound network requests to PostHog endpoints. You can confirm this by monitoring network traffic or by checking that `analytics.setEnabled(false)` reflects in the internal state.

### Will disabling telemetry affect application functionality?

No. The telemetry system is strictly passive collection. Opting out via the Settings UI, environment variable, or source build removal does not disable agent spawning, feature flags, or any core IDE functionality. The application degrades gracefully by simply skipping the analytics emission logic.

### What happens if I disable telemetry after the app has already sent some events?

Events are transmitted in real-time or near-real-time at session boundaries. Disabling telemetry via the Settings UI stops future emissions immediately, but events already dispatched to PostHog prior to the toggle cannot be retracted by the client. To prevent any transmission from the first launch, set `DO_NOT_TRACK=1` before starting the application for the first time.