It won't solve every routing problem, but it finishes.
When the tools of a craft reach their limits, the craftsman must sometimes forge new ones. A developer named Brian, confronted with a PCB so densely connected that conventional autorouters could not complete the task, built OrthoRoute — a GPU-accelerated plugin for KiCad that borrows its core algorithm from the world of FPGAs. In doing so, he demonstrated that the boundary between "impossible" and "merely unsolved" is often a matter of finding the right analogy from another domain.
- A PCB with thousands of nets pushed every available autorouting tool past its breaking point, leaving a designer facing months of manual work or outright failure.
- Brian built OrthoRoute from scratch, adapting PathFinder — an FPGA routing algorithm — to the orthogonal grid geometry of multi-layer PCB traces and vias.
- By offloading the massively parallel path-search computation to a GPU, routing time collapsed from months to hours, making previously intractable designs tractable.
- The tool is deliberately constrained — surface-mount components only, strict grid geometry — but that specificity is also what makes it fast and extensible.
- With the repository public and the hard algorithmic work already done, OrthoRoute lands as a foundation others can build on, not just a one-off solution to one engineer's problem.
Brian faced a circuit design problem that conventional tools simply refused to finish: a PCB so densely packed with connections that traditional autorouters gave up before completing the job. Routing thousands of nets by hand would have consumed months of painstaking work. Instead of accepting that fate, he built OrthoRoute, a GPU-accelerated autorouter that plugs directly into KiCad.
The approach is deliberately constrained. OrthoRoute lays traces in a Manhattan lattice — horizontal and vertical segments only, never diagonal — with all components surface-mounted on the top layer. Below that, a structured copper grid connects signals through blind and buried vias wherever a path needs to cross layers. The algorithm works iteratively, making repeated passes until it converges on a complete layout.
The real conceptual leap was borrowing PathFinder, an algorithm originally designed for routing signals through FPGAs. The parallel is elegant: both problems involve navigating a fixed orthogonal grid and punching vertical connections through it to complete a circuit. Moving that computation onto a GPU — which excels at running the same calculation across thousands of data points simultaneously — turned a months-long problem into one measured in hours.
Brian is candid that OrthoRoute solves a narrow problem for a small audience. But because it's structured as a modular KiCad plugin with the core algorithmic work already complete, it serves as a genuine foundation. Someone else could extend it for through-hole components, different via strategies, or new routing objectives entirely. The repository is public, and the next engineer who needs something like this won't have to start from nothing.
Brian faced a problem that would have crushed most circuit designers: a PCB so densely packed with connections that traditional autorouting tools simply gave up. Thousands of nets needed to be traced across the board—the kind of design that, routed by hand, would consume months of painstaking work and test the resolve of even the most patient engineer. Rather than accept defeat, he built OrthoRoute, a GPU-accelerated autorouter that plugs directly into KiCad. It won't solve every routing problem, and Brian is careful to note it's no more reliable than any other autorouter, but it does something the traditional tools couldn't: it finishes.
The name tells you how it works. OrthoRoute lays down traces in what's called a Manhattan lattice—a grid of perpendicular segments, all running either horizontal or vertical, never diagonal. All the components sit on the top layer of the board, surface-mount only; there's no accommodation for through-hole parts. Everything below that top layer becomes a structured grid of copper traces, connected vertically through blind and buried vias wherever a signal needs to jump between layers. The algorithm works iteratively, making passes through the design and gradually converging on a layout that actually works.
The real innovation isn't the grid itself—that's a known constraint in PCB design. The breakthrough is what Brian borrowed from a completely different domain. He adapted PathFinder, an algorithm originally built for routing field-programmable gate arrays. The conceptual overlap is striking: laying out a grid of orthogonal traces and punching vias through them to make connections is fundamentally similar to the problem of routing signals through an FPGA's fixed architecture. By moving that computation onto a GPU instead of grinding through it on a CPU, the whole process accelerates dramatically.
GPU acceleration matters here because the routing problem is massively parallel. A graphics processor excels at the same calculation repeated thousands of times across different data—exactly what you need when you're testing millions of possible trace paths and via placements. A CPU, processing these decisions sequentially, would be orders of magnitude slower. The GPU lets OrthoRoute handle designs that would have taken months to route by hand or would have simply exceeded the capacity of traditional tools.
Brian is realistic about what he's built. OrthoRoute solves a very specific problem for a very specific class of designs. In its current form, he estimates it's useful to maybe a handful of people. But because it's structured as a KiCad plugin and because the hard algorithmic work is already done, the door is open for others to extend it, modify it, or repurpose it for different constraints. The modular design means someone could adapt it for through-hole components, or different via strategies, or entirely different routing objectives. The GitHub repository is public, and the foundation is solid enough that the next person who needs something like this doesn't have to start from scratch.
Notable Quotes
OrthoRoute is no more trustworthy than any other autorouter, but at least it's fast— Brian, OrthoRoute creator
As-is, OrthoRoute is useful to maybe a handful of people at best, but as a KiCad plugin it's highly modular and the hard parts are all done— Brian, on the tool's current limitations and extensibility
The Hearth Conversation Another angle on the story
Why did Brian need to build this at all? Didn't KiCad already have autorouters?
It did, but they hit a wall with his design. Thousands of nets is beyond what traditional tools can handle in any reasonable timeframe. He was looking at months of manual work or accepting an incomplete routing.
So he borrowed an algorithm from FPGA design. Why does that work for PCBs?
Because the underlying problem is similar—you have a fixed grid structure and you need to connect points on that grid efficiently. FPGAs have been solved this way for years. He just adapted that proven approach to circuit boards.
The GPU part seems crucial. What's actually happening there?
Instead of a CPU checking routing possibilities one at a time, the GPU checks thousands in parallel. It's the same calculation repeated across different paths and vias. That's what GPUs are built for.
But he says it's not more reliable than other autorouters. So what's the actual advantage?
Speed, purely. It gets you to a working layout in hours instead of months. You still have to verify and probably hand-tune the result, but at least you have something to work with.
Is this going to change how people design PCBs?
Not immediately. Right now it's too specialized—surface-mount only, specific grid constraints. But it proves the concept works. Someone will take this and adapt it, and eventually GPU-accelerated routing might become standard.