A modern, open-source firewall for Windows 11, built on the Windows Filtering Platform

Deny every app by default. See exactly where your traffic goes, app by app and country by country. Decide who may reach the Internet, the LAN, or nothing at all — in a fast, modern interface with no accounts, no telemetry, and nothing between you and the kernel.

⬇ Download the latest beta

Installer or portable executable. No account, no telemetry, no ads.

GunWall is a zero-trust application firewall for Windows. It talks directly to the Windows Filtering Platform — the same kernel subsystem Windows Firewall uses — and adds three things Windows does not give you:

1. Default-deny for applications. Nothing reaches the network until you approve it, and every decision persists.
2. Real visibility. Per-app bandwidth measured from the kernel, live connection inspection, traffic broken down by app, host, protocol and country.
3. Expressive control. Ordered per-app rule lists that match on country, network operator (ASN), address range, or network scope — not just "allow" and "block".

It is a single portable executable. The filtering path — the WFP engine, the rule evaluator, the DNS resolver, the rule store — is the .NET base class library and Win32 and nothing else; the interface uses one MIT-licensed control library (WPF UI) for its Fluent controls.

GunWall is in public beta and is in daily use as a primary firewall.

The filtering engine, rule evaluation, monitoring, metering, DNS and blocklist subsystems are complete. Enforcement is verified against the Windows kernel rather than against GunWall's own reporting — you can confirm it yourself at any time with netsh wfp show filters, and this README shows you how.

What you should know before installing

• Filters are persistent. Closing GunWall, a crash, or a reboot does not stop enforcement. That is what a firewall must do.
• There are exactly two ways to stop filtering, and both return the machine to Windows defaults: the protection switch, and Remove all GunWall filtering. The uninstaller runs the second one for you.
• If GunWall will not start at all, GunWall.exe --unblock restores the machine from a command prompt without the interface.

What beta still means

GunWall runs as a single elevated process. Service isolation is the last architectural item before 1.0, and it is what separates tamper detection from tamper prevention.

It is deliberately not code-signed: a certificate is a recurring cost this free MIT project will not pass on or ask for. Each release publishes a SHA-256 instead, which you can check against source you can read.

It has been soak-tested for eleven hours at a stretch with no errors, but on a small number of machines. Your Windows build, your VPN and your security software are combinations nobody has tried.

• Zero-Trust mode — every program is denied by default and must be explicitly approved. Each new app raises an Allow / Block prompt that waits for you, and dismissing it blocks — a prompt closed by accident never grants access. Your choice persists. Loopback and core Windows networking stay allowed so the machine keeps working.
• Per-app rules — allow or block any executable, in either direction, with optional timed (auto-expiring) and silent (muted) variants. Critical system processes are guarded against accidental blocking.
• Per-app access rules — an ordered, first-match-wins policy per application. Rules target entities: domain, country, continent, ASN, IP, address range (CIDR), or network scope, each set to allow or block, with a default action when nothing matches. Presets included (Allow LAN only, Allow one country only, and more).
• Network scopes — per-app force-blocks by destination: device-local, LAN, Internet (LAN-only mode), incoming, server / listening sockets (denies the app any listening port, TCP or UDP), and P2P / direct (connections to addresses the app never resolved through DNS).
• Country & ASN blocking — block an app, or every app, from reaching a whole country, continent, or network operator.
• Custom rules — block or allow by remote IP / CIDR, port, protocol and direction, independent of any app.
• Block routed traffic — stop the machine acting as a router for a bridged VM, mesh-VPN peer, or shared connection. Traffic merely passing through never reaches the usual filtering layers, so this closes a gap most desktop firewalls leave open.
• Lockdown — cut all traffic instantly from the app or the tray, including routed traffic.
• Stealth mode — drop unsolicited inbound connections and ICMP error replies so the machine stops answering probes.

• Precise per-app metering — an optional ETW kernel session attributes bandwidth to processes from the Windows kernel network provider itself. A tested estimation engine runs as an automatic fallback, so usage data is never lost if metering is unavailable.
• Apps Usage Timeline — drag across the timeline to select any period and instantly see which applications were active in it, busiest first.
• Traffic breakdown — the current session split four ways: apps, remote hosts (with reverse-DNS names), traffic type (HTTPS, QUIC, DNS, VPN protocols, RDP, BitTorrent and more), and countries.
• World map — live connection arcs from your location to the busiest destinations.
• Live throughput graph — smooth download / upload chart with hover readout and session totals, plus a persistent status bar showing rates, totals, protection state and metering mode.
• Connection inspector — every live TCP connection and UDP socket (IPv4 + IPv6) with owning process, endpoints, state, country and ASN, with instant search. Right-click to close a connection, block the app, or terminate the process.
• Per-service attribution — service hosts are named, so a connection reads svchost (Windows Update) instead of one of a dozen identical svchost rows. A rule you can't explain isn't really control.
• Per-service rules — block one Windows service without touching the others sharing its process, so stopping telemetry doesn't also stop Windows Update.
• Packets Log — a live, searchable, color-coded log of every connection event, with the reason for each verdict, exportable to CSV.
• Network scanner — discover devices on your LAN (IP, MAC, host name).
• Notification center — session alerts for protection changes, threats and network events, with an unread badge.

• Secure DNS (DoH) — forward every lookup encrypted over HTTPS, so nobody on the network can read or tamper with what you resolve. Built-in providers are IP-addressed, so enabling encryption needs no plaintext lookup to bootstrap itself, and the default is to fail closed rather than silently downgrade.
• CNAME-cloaking defence — trackers dodge blocklists by aliasing a clean first-party name to a blocked one. GunWall follows each answer's alias chain and refuses the lookup if any hop is blocked.
• Built-in resolver — a from-scratch DNS resolver with caching and blocklist filtering, bound to loopback only. GunWall never changes this PC's DNS settings; point something at it deliberately to use it.
• Passive DNS watch — GunWall reads the lookup events Windows already emits, so domain rules and "block direct connections" know which name produced an address. Nothing is intercepted, redirected or answered.
• Domain blocklists — load a curated list (StevenBlack unified hosts, ~100k domains) or your own, applied at resolution time.
• Suspicious-domain heuristics — algorithmically generated domain names (a common malware signal) are scored and flagged using entropy, character-distribution and structural analysis.
• Filtering DNS — alternatively point Windows at a public filtering resolver (AdGuard for ads/trackers, Quad9 for malware/phishing).
• Captive portal helper — detects hotel/airport login pages and offers a temporary portal mode so you can get online.

• Authenticode signature verification — GunWall validates each program's digital signature with WinVerifyTrust, marking apps Valid signature, Unsigned, or Invalid signature, so a tampered or forged binary is flagged rather than trusted.
• Tamper detection — each rule stores the executable's SHA-256, so a swapped binary at the same path is detectable.
• VirusTotal lookup — check an app's hash against VirusTotal with your own API key; only the hash ever leaves the machine.

• Rule profiles — save and switch named rule sets (e.g. Home / Work / Travel).
• Versioned backups — automatic and on-demand snapshots of all rules and settings, restorable in one click.
• Windows Firewall integration — read its status, toggle it, and import its block rules.
• Kernel self-test — verify which Windows Filtering Platform layers and conditions this build of Windows accepts. A test filter is added and immediately removed on each; nothing is changed or left behind.
• Tamper detection — GunWall checks that its own filters are still installed and puts them back if something removes them, so interference is visible and short-lived rather than silent.
• Health & diagnostics — an app-health panel, a session error log, and a one-click diagnostics export bundling config, logs and network state.
• Run at startup — launch with Windows, elevated, without a UAC prompt, via a scheduled task.
• Close to tray — closing minimizes to the tray; a true exit warns if filtering is still active.
• Themes — matching dark and light themes with an animated switch.

• Windows 10 (2004+) or Windows 11, 64-bit
• Administrator privileges — WFP cannot add or remove filters otherwise. The manifest requests elevation automatically.

1. Go to Releases and download GunWall-<version>-setup.exe.

2. Run it. It installs to Program Files, offers to start GunWall with Windows, and registers an uninstaller.

   The uninstaller is the reason to prefer it. GunWall's filters live in the Windows kernel and persist after the application is gone, so deleting a folder leaves a machine still filtering with nothing installed to manage it. The uninstaller runs the full teardown first. Your rules and settings are kept unless you ask for them to be removed.

1. Download GunWall.exe from the same release.
2. Right-click → Run as administrator. Nothing is written outside the folder you run it from — but read Removing it below before deleting anything.
3. Windows SmartScreen will warn you. GunWall is not code-signed — a certificate costs money every year, and this is a free MIT project that would rather not charge for one or beg for it. Choose More info → Run anyway, or verify the SHA-256 checksum published with each release first, which proves the file is the one that was built from this source.

Verifying what you downloaded. Each release lists the SHA-256 of the executable. Check it before running:

certutil -hashfile GunWall.exe SHA256

If that matches the published value, the file is byte-for-byte the one built from this source. That is a stronger guarantee than a code-signing certificate gives you — a signature says someone paid for a certificate, a checksum against public source says this is that source, compiled.

Removing it. GunWall is portable, but its filters live in the Windows kernel and persist by design. Use Settings → Remove all GunWall filtering before deleting the folder — otherwise the machine keeps enforcing rules with nothing installed to manage them. If that already happened, see If the machine is locked.

GunWall starts in monitoring only — it observes traffic and changes nothing until you turn protection on. A good first session:

1. Watch the Dashboard and Apps list for a few minutes to see what your machine actually talks to.
2. Enable Zero-Trust mode when you're ready to start approving apps.
3. Optionally enable precise metering (Settings → experimental) for kernel-measured per-app bandwidth.

Expect prompts, and expect to be busy for the first ten minutes. Default-deny means every program asks once. Approve the ones you recognise; the ones you do not are the point of the exercise.

Two settings worth knowing about before you turn protection on:

Antivirus note: a firewall legitimately performs the same low-level operations malware does — modifying the hosts file, changing DNS, creating packet filters, terminating processes. Some behavioral engines may flag an unsigned build with a generic heuristic detection, especially when run from a Downloads folder. Build in Release, run from a stable folder, and add GunWall to your antivirus exclusions if needed. This is the trade that comes with an unsigned open-source binary, and it is a deliberate one — the source is here to read and build yourself.

GunWall is designed so that nothing happens to your data without your say-so:

• No telemetry, no analytics, no accounts, no phoning home. The only outbound lookups are ones you ask for: reverse-DNS for host names (the same query your OS already makes), optional VirusTotal hash checks, and blocklist updates.
• Local-only storage. Rules and settings live in a portable GunWallData folder beside the executable, falling back to %ProgramData%\GunWall if that's read-only — plain JSON you can read, back up, or delete.
• Explicit actions only. Every filter corresponds to a button you pressed. A fresh install changes nothing until you enable protection.
• Clean removal. Tear down every persistent filter from Settings before uninstalling.
• Nothing third-party decides anything. One MIT control library draws the interface; every component that inspects or blocks traffic is the .NET base class library plus Win32, and readable end to end.

GunWall runs as an independent filtering layer and does not modify your existing Windows Firewall rules.

┌──────────────────────────────────────────────────────────┐
│  WPF UI — dashboard · apps · traffic · connections ·      │
│  packets · DNS · rules · security · network · settings    │
├──────────────────────────────────────────────────────────┤
│  Event-driven detection loop + background sampler         │
│  FirewallManager · AppRuleEngine · RuleStore (JSON)       │
│  DnsResolver · GeoIP · ETW meter · usage & stats services │
├──────────────────────────────────────────────────────────┤
│  WfpEngine → fwpuclnt.dll   ·   WinVerifyTrust            │
│  ETW (advapi32) · hosts file · DNS · scheduled task       │
└──────────────────────────────────────────────────────────┘

Detection is event-driven off the WFP kernel event stream, not polling. Blocking an app adds persistent WFP filters (outbound + inbound, IPv4 + IPv6) keyed to the executable; Zero-Trust adds a base block plus per-app permits. Entity rules (country, ASN, scope) are enforced reactively — GunWall evaluates a connection when it appears and installs a matching filter. Filter IDs are persisted so every filter can be cleanly removed later, even across restarts.

Full details in docs/ARCHITECTURE.md.

Country and network-operator lookups use the free CC0 dataset from iptoasn.com, downloaded on request from Connections → Download GeoIP data. Nothing is sent anywhere: the tables are stored locally and every lookup is answered on your machine.

If you would rather run your own lookup service, GunWall can query a self-hosted iptoasn-webservice instead — set the address under Settings → GeoIP data source.

GunWall's filters are persistent by design — they keep enforcing after a crash, a close, or a reboot. If GunWall is not running, nothing can prompt, so a program without a rule fails silently.

From an elevated command prompt, in GunWall's folder:

GunWall.exe --unblock

This removes every filter, restores the hosts file and any adapter DNS GunWall changed, prints what it did, and exits without opening a window. It runs before any interface is built, so a broken window cannot stop it.

Verify it worked:

netsh wfp show filters file=%TEMP%\gw.xml

then search that file for 8f1d2b40-7c3e-4a51-9d6f-2a8c5e1b9f00. Zero matches means the machine is back to Windows defaults — and that is Windows reporting it, not GunWall reporting on itself.

Check before reopening GunWall. Starting it again immediately installs four filters that permit GunWall's own executable, so four matches after a restart is also correct and does not mean anything else is being filtered.

Zero-trust default-deny with first-connection prompts · ordered custom rules matching on address, port, protocol, domain, country and ASN · per-application domain blocking · a curated system-rule library · lockdown and snooze · live connections, packet log and per-application metering · a connection map · a local DNS resolver with DNS-over-HTTPS and blocklists · Authenticode and hash verification · VirusTotal lookups · network scanning with device identification · rule profiles · full diagnostics export · verified recovery to Windows defaults.

Per-category blocklist controls · IPv6 country coverage for the map · MAC vendor identification · mDNS device names · attributing a kernel drop to the specific filter that caused it · list view modes.

Pico and WSL process identification · connect-redirection and discard layers · tamper prevention, which requires the service split · per-network trust profiles · boot-time filters · Windows Update repair · encrypted profiles · one-click update from inside the application · multi-language interface.

Code signing. A certificate is a recurring cost this project will not pass on or ask for; the published SHA-256 proves more, against source you can read. A donated open-source certificate would be used gladly, but nothing waits on it.

Full detail, grouped by area and risk, is in ROADMAP.md.

Beta feedback is the most useful thing you can send. What makes a report actionable:

1. Settings → Export diagnostics (.zip) — it contains the session log, your settings with secrets removed, the active rules and your network configuration. No browsing history and no personal data.
2. Describe what you saw, not what you think caused it. "The firewall says it is off when it is on" once led straight to a bug that turned out to be invisible text — a diagnosis would have sent us the wrong way.
3. A full-window screenshot if it is visual. A crop hides what an element is being measured against.

Open an issue at github.com/ox1d3x3/gunwall/issues.

If something is badly broken and you need the machine working now, run GunWall.exe --unblock first, then report — recovery does not destroy the log.

MIT.

Credits. GeoIP data from the public-domain iptoasn dataset, served via jedisct1/iptoasn-webservice (BSD-2-Clause). Domain blocklist from StevenBlack/hosts (MIT). Country flag icons from FlagKit (MIT) — see Flags/LICENSE-FlagKit.txt.

The mark is a wall of sixteen stones with three that are not ordinary: one missing, one stopped in red, and one drawn as an outline — a barrier, a block, and something under watch. Source artwork and every derived size live in branding/ (SVG, PNG, lockups and app icons).

The red in the mark is deliberately not the interface accent. In GunWall red means blocked, so the logo says the same thing the application does.