Inspiration
Our homes are full of devices that talk to the internet constantly: TVs, phones, cameras, speakers. While setting up Eddie we watched a single Fire TV send thousands of lookups to Amazon telemetry servers, and a phone ping analytics SDKs several times per second in a retry loop. None of it is visible to the people living there.
We kept coming back to one question: what could a stranger learn about your household just from the names your devices look up? When you wake up, when the house is empty, what health or money apps you use. And the one that scared us most: indoor cameras that keep uploading video while you're home. We wanted a guard that sits between the home and the internet, explains what's happening in plain English, and lets you stop it, without sending your data to yet another cloud.
What it does
Eddie is a privacy guard that runs entirely on a Raspberry Pi 5:
- Sees every lookup. Devices use Eddie as their DNS server, so Eddie logs which device tried to reach which name.
- Blocks trackers and data brokers using blocklists, CNAME checks, keyword heuristics, your own rules, and a small local AI that classifies unknown domain names.
- Modes for real life:
- Home mode cuts indoor camera uploads while people are home, even a stream that's already running.
- Kid mode locks children's devices down to an allowlist.
- Guest mode lets visitors ask Eddie about the Wi-Fi or the thermostat, but not about the household's traffic.
- Away, offline, quarantine for new devices, and spoof mode, which feeds trackers fake answers instead of a block.
- Talks. Say "Hey Eddie, what do companies know about me?", "When could someone tell the house was empty?" or "Turn on home mode". Wake word, transcription and reasoning all run offline on the Pi.
- Shows it. An iPad dashboard shows a live feed, devices, rules and modes, and Eddie changes outfit with the mode (a bellhop hat for guest mode, Pinocchio for spoof mode).
How we built it
- DNS core: a Python DNS server (
dnslib) that answers every lookup on the network. It decides allow / block / spoof / flag, logs to SQLite, and forwards allowed lookups upstream. Model calls stay off the DNS hot path: unknown names are answered right away and classified in the background by a separate local classifier service. - API: a FastAPI service for rules, modes, devices and reports (
/what-they-know,/burglars-eye,/tracker-map). - Acknowledged state: every mode change bumps a revision number, and the API waits until the DNS server confirms it loaded that revision before saying "done". Eddie never claims a block works just because a flag was saved.
- Voice: Vosk for the "Hey Eddie" wake word, Whisper for transcription, and deterministic command parsers plus a small local intent model for routing. Audio stays in memory, and transcripts are never written to disk.
- Dashboard: plain HTML/JS on the iPad, fed by a server-sent event stream. Controls need a pairing token, and the microphone can only be switched on from the Pi itself.
- Router mode for home mode: the Pi forwards and NATs a device's traffic. An
nftablesset (homeblock) drops a camera's packets the moment home mode turns on. - Ops: systemd units for each service, and the Pi pulls
mainevery 5 minutes so the team can ship from laptops.
Challenges we ran into
DNS can't stop a stream that's already running. Our first home mode only blocked the camera's upload lookup. But a live stream is one long connection: once the phone had resolved a.rtmp.youtube.com, blocking the next lookup changed nothing. We had to make the Pi the phone's router and drop packets with nftables.
Then the router dropped our packets. With the Pi forwarding but not translating addresses, the phone's connection attempts reached our home router and got no answer. Adding NAT (masquerade) on the Pi fixed it instantly: the upload went from 0 to about 426 KB in 10 seconds.
A button press erased our router. The small button on the Pi 5 board is its power button. One press rebooted it, wiping the forwarding settings and firewall table we'd set by hand. The phone, still routing through the Pi, just showed "connection timeout". We saved the forwarding settings permanently. The firewall table still has to be recreated after a reboot, and making Eddie do that by itself is next on our list.
Reconnecting is slower than cutting. Eddie's blocked answer carries a 60-second TTL, so after home mode turns off, an app that retries within that minute still gets the blocked answer. The worst-case recovery is roughly
$$ t_{\text{recover}} \lesssim \text{TTL}{\text{block}} + t{\text{retry}} \approx 60\,\text{s} + t_{\text{retry}}, $$
which is why our demo restarts the stream by hand after home mode goes off.
Speech recognition vs. our vocabulary. Whisper kept hearing "kid mode" as "kit mode", "hit mode" or even "hidden mode", so the parser treats those as kid mode. Other gremlins: a USB speakerphone that came loose mid-test, and iPad Safari only playing Eddie's voice after a tap on every reload.
What we learned
- DNS sees a lot, but only names. It can show who talks to whom, but not content, and it can't stop a connection that's already open. Real enforcement needs a router.
- "Saved" is not "applied". Building revision acknowledgment into every mode change caught real bugs where the UI said "on" before DNS had loaded the change.
- Local AI is practical on a Pi 5: wake word, transcription and domain classification all run offline, as long as they stay off the latency-critical path.
- Hardware is the hard part. Power buttons, loose USB cables, router quirks and Wi-Fi settings cost us more time than any feature.
What's next
- Recreate the firewall table and NAT automatically on boot.
- A full router mode where the Pi broadcasts its own "Eddie" Wi-Fi, so devices don't need manual settings.
- Shorter block TTLs for home mode, so streams recover faster.
- Per-device privacy grades (A–F) and a spoken nightly report.