Skip to content

Real-time network monitor + outbound firewall — see & block every connection. Privacy-first, local-first, Rust fleet agent, SIEM exports, 8 languages. / Moniteur réseau temps réel + pare-feu sortant, agent de flotte Rust, exports SIEM. 100 % local.

docs: 4 more SEO articles - linux alt, glasswire alt, how-to, founder story

MoneyLisaffaae9431ff9
diff --git a/docs/articles/glasswire-alternative.md b/docs/articles/glasswire-alternative.md
new file mode 100644
index 0000000..220b68e
--- /dev/null
+++ b/docs/articles/glasswire-alternative.md
@@ -0,0 +1,47 @@
+If you've searched for a network monitor on Windows, you've hit GlassWire. It's polished, it looks great — and then the paywalls start showing up: history behind a subscription, firewall features behind tiers, an account that keeps being suggested, cloud "elite" sync.
+
+There's nothing wrong with paying for software. But "show me what my computer connects to" is basic hygiene — it arguably shouldn't be gated at all. I'm the author of [Snitch](https://github.com/aixisstudio/Snitch), a free, open-source (AGPL) alternative, so let me give you the honest comparison instead of a sales pitch.
+
+## Snitch vs GlassWire, feature by feature
+
+| | **Snitch** | **GlassWire** |
+|---|---|---|
+| Price | Free, forever | Freemium — key features paywalled |
+| License | AGPL open source | Proprietary |
+| Account | **None — ever** | Account/cloud tier promoted |
+| Telemetry | **Zero outbound calls** (GeoIP download is opt-in) | Phone-home for sync/features |
+| Data location | Local SQLite, yours | Cloud-linked features exist |
+| Live world map of connections | ✅ geolocated offline | ✅ (paid tiers) |
+| Per-app traffic & bandwidth | ✅ | ✅ (partially free) |
+| History | 24h free (SQLite ring buffer) | Limited on free tier |
+| Anomaly alerts (port scans, beaconing, exfil) | ✅ | ✅ (mostly paid) |
+| LAN device scan | ✅ passive, via ARP | ✅ (paid) |
+| Firewall / blocking | ❌ visualizer only | ✅ (this is GlassWire's real strength) |
+| Platforms | macOS, Windows, Linux | Windows, Android |
+| Privacy score / tracker detection | ✅ editable lists | ❌ |
+
+## Where GlassWire still wins
+
+Being fair:
+
+- **Blocking.** GlassWire has a real application firewall. Snitch deliberately doesn't block — it shows you, it doesn't decide. If "deny this app" is your core need, GlassWire (or free Portmaster) is the right tool.
+- **Polish.** GlassWire's had a decade of UI work. Snitch is 3 weeks old — the graph is great, the settings are functional, expect edges.
+- **Long history retention** — Snitch keeps 24h by design (privacy-first means *not* hoarding your traffic either).
+
+## The architecture difference that matters
+
+GlassWire's model is the industry's: free tier → annoyance → subscription → cloud features. Snitch's model is the opposite: the binary you run is the whole product. Nothing to unlock because nothing is locked. Your traffic history lives in a local SQLite file — and the code is AGPL, so it can't quietly start phoning home without the diff being public.
+
+Concretely: API on loopback with token auth, zero telemetry endpoints, no analytics SDK anywhere in the code (you can grep it — it's open source).
+
+## Try it
+
+```bash
+# Windows: install Npcap, then run the release exe as Administrator
+# Linux/Docker:
+docker run --network host ghcr.io/aixisstudio/Snitch
+# macOS: packaged app or brew
+# Demo mode without admin: SNITCH_DEMO=1
+```
+
+Repo: https://github.com/aixisstudio/Snitch — issues and feature requests welcome, the Windows port itself was community-contributed. If it replaces a subscription you didn't want, that's the point. ⭐ if it does.
diff --git a/docs/articles/little-snitch-alternative-linux.md b/docs/articles/little-snitch-alternative-linux.md
new file mode 100644
index 0000000..9ae0dff
--- /dev/null
+++ b/docs/articles/little-snitch-alternative-linux.md
@@ -0,0 +1,47 @@
+Your computer talks to hundreds of servers a day. On Linux the classic answers are `tcpdump`, `ss`, `netstat`, or Wireshark — powerful, but they answer "show me packets", not "who is my machine talking to, and should I worry?".
+
+I built [Snitch](https://github.com/aixisstudio/Snitch) for that second question — an open-source (AGPL) real-time network visualizer, and it's fully supported on Linux via Docker or the release binary. Full disclosure: I'm the author, so here's an honest rundown of what exists and where Snitch fits.
+
+## The Linux landscape
+
+| Tool | What it does | What it doesn't |
+|---|---|---|
+| **tcpdump / ss / netstat** | Raw connection data | No UI, no history, no geolocation, no app mapping |
+| **Wireshark** | Deep packet dissection | Overkill for "who's phoning home" — it's a microscope, not a dashboard |
+| **OpenSnitch** | Application firewall (block/allow prompts) | Minimal visualization — it's block-first, and it's Linux-only |
+| **iftop / nethogs / nload** | Per-interface or per-process bandwidth | No world map, no anomaly detection, no persistence |
+| **Snitch** | Live map of every connection: app → server → country, anomaly detection, 24h history | Doesn't block (by design — it's a visualizer) |
+
+OpenSnitch and Snitch are complementary, not competitors: OpenSnitch decides *whether* a connection is allowed, Snitch shows you *what* your machine is doing.
+
+## What Snitch gives you on Linux
+
+- **Live world map** of every outbound connection, with process attribution — which app opened it, not just which IP
+- **Offline geolocation** via a local MaxMind/DB-IP database — your IPs never leave the machine
+- **Anomaly detection**: port scans on your LAN, beaconing (regular-interval callbacks, a classic C2 pattern), unusual outbound volume
+- **Privacy score** + tracker detection from editable suffix lists
+- **Per-app bandwidth**, timeline, 24h SQLite retention, alert suppression rules
+- **Passive LAN scan** via the system ARP table — every device on your network, no packets injected
+- Bilingual EN/FR UI (中文 README too)
+
+## The privacy part
+
+This is the part Linux users tend to verify first, so: the API binds to **127.0.0.1** and requires a token. There is **no telemetry, no account, no outbound call at all** except an explicitly consent-gated GeoIP database download. Traffic data lives in a local SQLite file you own.
+
+## Install
+
+```bash
+# Docker (host networking needed for packet capture)
+docker run --network host ghcr.io/aixisstudio/snitch
+
+# or the release tarball — needs root/cap_net_raw like tcpdump
+sudo ./snitch-backend
+```
+
+Then open the printed URL. There's also a demo mode (`SNITCH_DEMO=1`) that feeds synthetic traffic through the real pipeline if you want to look before granting capture rights.
+
+## What's under the hood (for the curious)
+
+Pure Python + ctypes → libpcap for capture — no Scapy dependency. The IPv4/IPv6/TCP/UDP/DNS/TLS-SNI parsing is hand-rolled, ~2K lines for the whole pipeline. FastAPI + WebSocket backend, React + D3 frontend, Electron shell on desktops.
+
+If you want a "does my machine talk to weird places at 3am" answer on Linux without paying for a firewall or running a packet capture all day — that's exactly what this is for. ⭐ on [GitHub](https://github.com/aixisstudio/Snitch) if it earns it, and the repo's Discussions has a "what did you catch?" thread I'd love to see your screenshots in.
diff --git a/docs/articles/see-every-connection.md b/docs/articles/see-every-connection.md
new file mode 100644
index 0000000..dbe541e
--- /dev/null
+++ b/docs/articles/see-every-connection.md
@@ -0,0 +1,63 @@
+Your computer is talking to the internet right now. Probably dozens of connections — sync, telemetry, update checks, your open tabs, your apps' background chatter. The question "what is my machine actually doing?" sounds basic, but try answering it and you'll find the tooling is either microscopic (Wireshark) or paywalled.
+
+Here's a practical guide to actually seeing it — including the tool I built for it, [Snitch](https://github.com/aixisstudio/Snitch) (open source, AGPL — disclosure, it's mine).
+
+## The 60-second version
+
+```bash
+# macOS / Linux — classic but raw
+sudo tcpdump -i any -n | head -50 # every packet, no context
+netstat -anp tcp | grep ESTABLISHED # current connections only
+lsof -i -nP | head # process → socket mapping
+
+# Windows
+netstat -ano | findstr ESTABLISHED
+Get-NetTCPConnection -State Established # PowerShell
+```
+
+These answer "what connections exist right now". They don't tell you which app, where the server is, or whether it's suspicious. That gap is exactly what a visualizer fills.
+
+## The visualization approach
+
+Snitch renders every connection as a live graph + world map:
+
+- **Node = your machine** at the center, lines to every remote endpoint
+- **Each endpoint labeled**: hostname (via reverse DNS + TLS SNI), geolocated country/city — all offline, from a local MaxMind/DB-IP database
+- **Per-app attribution**: the connection is drawn to the *process* that opened it
+- **Timeline**: 15/30/60-min traffic volume, 24h of history in a local SQLite file
+
+What makes it different from tcpdump: the data is *already processed*. Not "packet to 142.250.74.78" — "Chrome → google.com → Frankfurt".
+
+## Reading the map: normal vs suspicious
+
+What a normal map looks like: spokes to Apple/Google/Microsoft/your browser tabs' CDNs, your router, other LAN devices.
+
+What stands out:
+
+- **Beaconing** — a connection that fires at regular intervals (Snitch flags these; it's a classic C2 pattern)
+- **Long-lived uploads to unfamiliar endpoints** — data leaving steadily to somewhere you don't recognize
+- **Port scans** — a LAN host touching many ports on your machine gets flagged
+- **Apps talking to countries that make no sense** for what the app does
+- **Trackers** — Snitch cross-references hostnames against editable tracker suffix lists and factors them into a privacy score
+
+The built-in **anomaly detection** watches for all of these automatically, and you can suppress alerts per-rule once you've vetted a pattern.
+
+## Install it (2 minutes)
+
+```bash
+# macOS: download the app from releases, or brew
+# Windows: install Npcap → run snitch-backend.exe as Admin
+# Linux / Docker:
+docker run --network host ghcr.io/aixisstudio/snitch
+
+# No admin rights? Demo mode shows the full UI with synthetic traffic:
+SNITCH_DEMO=1 snitch-backend
+```
+
+Everything stays local — token-authenticated API bound to loopback, zero telemetry, no account. That's not a marketing line; it's an AGPL codebase, you can verify the network code path yourself.
+
+## Then what?
+
+Once you can *see* the traffic, the interesting part starts — the community's favorite pastime is the ["What did you catch?" thread](https://github.com/aixisstudio/Snitch/discussions/39): printers talking to cloud servers at 3am, TV telemetry, the works.
+
+Repo: https://github.com/aixisstudio/Snitch — ⭐ if it answers the question it set out to answer.
diff --git a/docs/articles/why-i-built-snitch.md b/docs/articles/why-i-built-snitch.md
new file mode 100644
index 0000000..194c2e0
--- /dev/null
+++ b/docs/articles/why-i-built-snitch.md
@@ -0,0 +1,47 @@
+Three weeks ago I wanted to answer a stupidly simple question: **who is my computer talking to?**
+
+Not "can I capture packets" (Wireshark can, and it's a microscope when I wanted a windshield). Not "block connections" (Little Snitch does that on macOS, $59, and nothing equivalent exists on Windows). Just: a live, visual answer. Which app, which server, which country — right now.
+
+So I built [Snitch](https://github.com/aixisstudio/Snitch). Open source, AGPL, EN/FR UI, ~400 stars in three weeks. Here's what I learned — and the part where strangers wrote my Windows port for me.
+
+## The build
+
+The constraint I set myself: **no heavy dependencies, no telemetry, ever.**
+
+- Capture: `ctypes → libpcap` on macOS/Linux, Npcap on Windows. No Scapy — direct bindings are lighter and give exact field control.
+- Parsing: hand-rolled IPv4/IPv6/TCP/UDP/DNS/TLS-SNI decoders. ~2K lines for the entire pipeline.
+- Backend: FastAPI + WebSockets + a SQLite ring buffer (24h retention, then it deletes itself — privacy means *not* hoarding either).
+- Frontend: React + D3 force graph + TopoJSON world map.
+- Geolocation: local MaxMind/DB-IP file. IPs never leave the machine.
+
+Security posture as a feature: API on loopback only, token-authenticated, zero outbound calls unless the user explicitly consents to the GeoIP download. For a privacy tool, the code *is* the promise — AGPL makes it auditable.
+
+## The thing I didn't plan
+
+I shipped macOS first and tagged the repo "help wanted" on Windows. Within days:
+
+- Users filed bug reports with **root-cause analysis included** — not "it doesn't work", actual stack traces and the faulty capture path identified
+- A stranger I'd never spoken to sent three PRs: Npcap capture, network interface selection, a startup crash
+- Someone else opened the [winget package PR](https://github.com/microsoft/winget-pkgs/pull/455520)
+
+v1.0.5 shipped last week with the Windows port fully working. The most powerful distribution channel this project found wasn't a marketing trick — it was "put a real problem in public, and people who have the same problem show up".
+
+## What the traffic data said
+
+Fun meta-moment: Snitch's own referral traffic told the story. A Chinese tech newsletter (ruanyifeng.com) featured the project — suddenly ~20% of traffic was Chinese readers staring at an English README. So now there's a full [中文 README](https://github.com/aixisstudio/Snitch/blob/main/README.zh-CN.md). The data decides; I just listen.
+
+## What I'd tell anyone building dev tools
+
+1. **Solve a felt problem.** "Who is my machine talking to" is visceral — everyone wonders, nobody can see it.
+2. **Local-first is a differentiator now.** "No account, no telemetry" isn't a limitation, it's the pitch.
+3. **Bilingual/multi-language docs aren't charity** — they're distribution to audiences with zero competition.
+4. **Issues and Discussions convert.** Fast answers turned bug reporters into contributors. That's how my Windows port happened.
+
+## Try it
+
+```bash
+docker run --network host ghcr.io/aixisstudio/snitch # Linux
+# macOS/Windows: releases page — SNITCH_DEMO=1 runs it without admin
+```
+
+Repo: https://github.com/aixisstudio/Snitch — AGPL, bilingual EN/FR (+中文). The ["what did you catch?" thread](https://github.com/aixisstudio/Snitch/discussions/39) is open, and a ⭐ genuinely helps if it earns it.