Why Routerly Exists: Network Configuration Shouldn't Require a PhD

The Problem with Network Configuration Today

Let me paint a picture: You’re deploying edge devices for a client. Maybe it’s a defense contractor, maybe it’s a factory floor, maybe it’s a remote office. You need to set up basic routing rules—allow this subnet to reach the internet, deny guest access to internal resources, prioritize video traffic.

Simple concepts, right?

Now try expressing those concepts to your router. Suddenly you’re navigating vendor-specific GUIs with twelve nested menus, or typing cryptic commands that look like iptables -A FORWARD -s 192.168.1.0/24 -d 10.0.0.0/8 -j DROP. And heaven help you if you need to remember which vendor uses which syntax.

There Has to Be a Better Way

I’ve been working with Linux networking tools for years, and while they’re powerful, they’re not intuitive. Every time I configure a router, I end up:

1. Googling the exact syntax I need
2. Reading through man pages written for kernel developers
3. Testing carefully because one typo could lock me out
4. Documenting everything because I’ll forget it in six months

That’s fine for hobbyists and full-time network engineers. But what about the operator who just needs to get devices talking safely? What about the developer who understands concepts but not implementations?

The Routerly Philosophy

Routerly started with a simple question: What if networking spoke human?

Not dumbed-down. Not abstracted into uselessness. Just… understandable.

routerly allow home access to internet
routerly deny guest access to printer
routerly prioritize video traffic on wan

No IP addresses unless you need them. No memorizing chains and tables. No vendor lock-in. Just English sentences that express intent clearly.

Under the Hood: Pragmatism Over Perfection

Here’s where I could tell you I’m building a revolutionary packet processing engine from scratch. But I’m not.

Routerly is Go wrappers around proven Linux networking tools—primarily nftables and standard Ubuntu networking utilities. Why reinvent the wheel when Linux already handles routing, firewalling, and traffic shaping reliably?

The innovation isn’t in packet processing. It’s in the interface layer that translates human intent into proper nftables rules. It’s in the Ubuntu Core foundation that keeps everything secure and updatable without manual intervention.

Who This Is For

I’m building Routerly for:

• Edge device operators who need reliable routing without networking expertise
• Defense contractors deploying systems where clarity is critical
• Enterprise deployments where consistency matters more than flexibility
• Embedded system developers who want networking that just works

If you’re a network engineer who loves writing custom iptables chains, Routerly probably isn’t for you. And that’s okay! There’s room in the world for both approaches.

Current Status: Honest Roadmap

Let me be transparent about where we are:

• Q1 2026 (now): Website, core architecture design, initial Go wrapper development
• Q2 2026: Basic routing functionality, documentation, first deployable builds
• Q3 2026: Security hardening, performance testing, early adopter program
• Q4 2026: v1.0 release candidate

This is a nights-and-weekends project. I’m a solo developer who believes in building in public and shipping incrementally. Expect honest updates, reasonable timelines, and software that works—even if it doesn’t have every feature you might want on day one.

Join the Journey

If this resonates with you, I’d love to have you along for the ride:

• ⭐ Star the GitHub repo
• 💬 Join discussions in the issues
• 📖 Contribute to documentation
• 🐛 Report bugs (there will be bugs!)

Routing should be simple. Let’s make it happen.

Routerly is open source under MIT license. Built with Ubuntu Core and Go.