We Said No to Telemetry
Somewhere in the early stages of building these utilities, a reasonable question came up: should we add analytics?
It’s a perfectly normal thing to do. Most apps collect some form of telemetry — crash reports, feature usage, session duration, OS version, that sort of thing. The data is usually anonymised, the intentions are usually good, and the justification is always the same: we need to understand how people use the app so we can make it better.
We thought about it for roughly fifteen seconds.
No.
What we don’t collect
Let’s be specific, because vague privacy promises are worth precisely nothing:
- No analytics. We don’t track which features you use, how often you open the app, or how long you leave it running.
- No crash reports. If the app crashes, we don’t know about it unless you tell us.
- No network requests. The apps make exactly zero outbound connections — with one exception: the update checker, which hits the public GitHub API to compare version numbers. That’s it. No tracking pixels, no CDN pings, no “anonymous” device fingerprints.
- No data leaves your machine. Your clipboard history stays in ClipMan’s local database. Your calendar events stay in CalendarUpcoming’s memory. Your pinned windows stay in WindowPin’s process. Nothing is transmitted anywhere.
- No third-party SDK. No Firebase, no Amplitude, no Mixpanel, no Sentry, no anything. The apps have no dependencies that phone home.
Why not?
Because telemetry is a slippery slope wearing a lab coat.
It starts with “let’s just collect crash reports” and ends with a 47-page privacy policy that references the California Consumer Privacy Act. We’ve all seen the progression. First it’s diagnostics, then it’s “anonymised” usage patterns, then it’s A/B testing, then someone suggests “just a small amount of behavioural data to improve the onboarding flow”, and before you know it your clipboard manager is sending heartbeat pings to a server in Virginia.
We didn’t want to be on that slope at all. Not because we think everyone on it is evil — most aren’t — but because the easiest way to guarantee user privacy is to never collect anything in the first place. You can’t leak data you don’t have. You can’t be compelled to hand over records that don’t exist. You can’t accidentally expose information you never gathered.
It’s a surprisingly liberating engineering constraint. No backend to maintain, no data pipeline to secure, no GDPR compliance to audit, no cookie banners to argue about, no privacy policy that needs a law degree to parse.
The open-source angle
This is also why every app is open source and public domain. You don’t have to take our word for any of this — you can read the code. Every line of it.
There’s no hidden network layer. No obfuscated tracking module. No conditional telemetry that activates after 30 days. The source is right there on GitHub, and it builds to exactly the binary you download from the releases page.
We’ve had people ask: “Why would you give your software away for free with no conditions?” Partly because we think it’s the right thing to do. Partly because open source is the only credible privacy guarantee. A closed-source app that claims not to collect data is asking you to trust a promise. An open-source app that doesn’t collect data is showing you proof.
The update checker
In the interest of full disclosure: the one network request our apps make is to api.github.com to check for updates. This is a standard GitHub API call that returns the latest release tag. GitHub may log the request as part of their normal API operations — we have no control over that and no access to those logs.
The update check is optional. You can set the interval to “Never” in Settings and the app will never make any network request at all. Zero bytes in, zero bytes out.
What we lose
Let’s be honest: we lose some things by not collecting telemetry.
We don’t know how many people use our apps. We don’t know which features are popular and which are ignored. When someone hits a bug, we rely on them opening a GitHub issue — and most people won’t. We’re probably making some decisions in the dark that would be better informed by data.
That’s a trade-off we’re comfortable with. We’d rather ship software that respects you and occasionally guess wrong about what to build next, than ship software that watches you and always knows exactly what to optimise.
The short version
Your apps are yours. They run on your machine, they stay on your machine, and they mind their own business. That’s not going to change.
If you appreciate this approach, the best thing you can do is tell a friend. Or buy us a coffee. Or just keep using the apps. That’s enough.