Enterprise-grade, from scratch
2.7 million lines of Rust, sixty-nine crates, one binary, an OOB server we own, and an AI that writes its own exploits. Almost a year of building Hugin to a bar that is not easily achievable.
Hugin looks brutalist. Carbon-black, one ember orange, a sliced-H on the favicon. That is theme and logo, and it is a fact about how the thing presents. It is not what matters.
What matters is the bar. Enterprise-grade, written from scratch. Not a wrapper. Not a fork. Not a plugin on someone else’s engine. Two point seven million lines of Rust, sixty-nine crates, one native binary, built until it meets the standard a professional pentester can run a practice inside. That is not easily achievable. I want to say plainly what it took, because the launch version is about to ship and the scale is the point.
Almost a year ago Hugin was a proxy that worked on my laptop and nowhere else. Today it is the closest thing I have built to an unbuildable thing. An arsenal. The kind a professional pentester actually earns a living inside.
The number nobody likes to talk about
Two point seven million lines of Rust sounds absurd for one person, and it is. It is also the honest count. Every line is mine or it is not in the tree. No wrapper around Burp, no fork of someone else’s proxy, no plugin somebody else maintains. Sixty-nine crates, one workspace, one binary that runs on your machine and asks nothing of a cloud.
I did not set out to write 2.7 million lines. I set out to build a proxy that high-end competitors did not have, and the only honest way to do that was to write the engines myself. The scanner, the intruder, the smuggling kit, the race engine, the out-of-band detection, the AI control layer. When you write your own engines instead of wrapping someone else’s, the line count stops being a vanity metric and starts being the bill for doing it properly.
That bill came due almost a year ago. I have been paying it since.
An OOB server we actually run
This is the part I am proudest of, and it is the part most tools fake.
Every pentester knows the move. You find a blind injection, a blind SSRF, a blind deserialization, and you need the target to phone home to prove it. Burp sells you Collaborator and runs the box. Most other tools just point you at one.
Hugin ships its own out-of-band server. Not a client that talks to someone else’s. The server itself, written in Rust, listening on eleven protocols: DNS, HTTP, HTTPS, SMTP, LDAP, FTP, SMB, plus RMI, gopher, TFTP, and raw TCP for the harder chains. Every callback lands on infrastructure you control, on a domain you own, encrypted to a key that never leaves your machine. When a target authenticates back over SMB, the server decodes the handshake and writes you a hashcat-ready NetNTLMv2.
That is not a feature you ship by wiring an API. That is a server, from scratch, in the same workspace as the proxy. It took months. It is done.
AI native, not AI bolted on
When I started building Hugin’s MCP layer there was no talk of agents in this tooling. That has changed. Burp added an “Explore Issue” feature that autonomously investigates scanner findings and attempts exploits, plus AI credits, an explainer, and AI-generated login sequences. Caido added a Client SDK and a bring-your-own-model AI that plugs into OpenAI, Anthropic, Google, or OpenRouter through paid-tier plugins. I am not going to pretend either of them is nothing.
But both are still an AI you bolt onto a tool, not a tool built around the AI. Burp’s AI runs on PortSwigger’s cloud, you buy credits for it, and it only fires when you click a button. Caido’s model is external, the surface is an SDK and a GraphQL API. Neither has an MCP layer. Neither was designed from the metal up to be driven by an agent.
Hugin was. One hundred and sixty-nine MCP tools, all callable from your agent. The AI lives inside the proxy, on your machine, no credits, no vendor cloud. It reads every flow, reasons over the application’s real attack surface, and writes its own exploits. At line rate. Not a button that sends a request to a hosted model and shows you a paragraph. The agent calls the same engines I call, with the same context I have, and it can drive all of them.
Privacy is the point
There is one more thing the competitors will not give you, and it matters more than it sounds.
Caido, by their own privacy notice, collects interaction data between your instances and their cloud services: your instance IP, API call actions, timestamps. Burp runs its AI through PortSwigger’s cloud, paid in credits you buy from an account with your name on it. Both of them want to know who you are.
Hugin does not. No account. No email. No telemetry. Pro against an anonymous numbered account, no identity, no identifiers. I do not want to know who the pentester is. I want the pentester to have the tool. That is the whole model. Your research traffic, your findings, your proof, stay on your box. The box where Hugin runs is the only box that sees them.
What it actually replaces
A professional pentester’s kit is not one tool. It is a stack: a proxy, a scanner, an intruder, a collaborator server, a smuggling kit, a race tool, an extension runtime, an AI agent. Until recently that stack was Burp plus Collaborator plus a cloud account plus whatever you wired yourself.
Hugin is the whole stack, in one binary, on your machine. Fifty-five active checks, forty-eight passive, a race-condition engine that does single-packet and last-byte sync, smuggling across CL.TE and TE.CL and TE.TE and H2.TE plus gRPC differential, Lua extensions sandboxed across fourteen permission-gated hooks, WASM scanner modules under a fuel cap, an OOB server on eleven protocols, and an AI agent that drives all of it. Community is free. Pro is a flat seven euros.
I am not pretending that is a small thing. It is almost a year of my life.
The hunter’s programs, inside the tool
The engines are half of it. The other half is knowing what you are allowed to touch.
A bug bounty hunter does not just have targets. They have programs: public ones, private ones, each with its own scope, its own rules of engagement, its own bounty table, its own response SLA. Until now you kept that in a browser, in a spreadsheet, in your head. The proxy did not know.
Hugin knows. Every project carries its own scope, its own rules, its own payout ranges, its own known exclusions. The platform integrations pull your programs in: YesWeHack live, HackerOne wired. Public programs and the private ones you were invited to, both, with the scope enforced on the tools so you do not cross it by accident.
That is not glamorous work. It is the work that stops you from testing out of bounds and burning an invitation. It belongs inside the tool, not in a separate tab you forget to check.
The face
So yes, Hugin got a face this week too. An H, cut by a clean horizontal slice, in ember on carbon-black. One mark, drawn once, used on the app, the site, the socials, the favicon here on the blog.
I gave it a real identity because it earned one. A tool this size, that you hand your research traffic and your findings and your proof, should not look like a side project. It does not look like one anymore. Not because of the logo. Because of the 2.7 million lines beneath it.
If you live in a proxy all day, this is built for you.
More plugins are on the way. Stay tuned.