It's probably because most people who come into PCB design assume autorouting is like a compiler: you just need to design the schematic and then the computer does the rest for you. Even with very good autorouting this is never the case, and if you assume so, especially as a beginner, you will wind up with hilariously bad results. This is why experienced PCB designers will often smack the beginner's hand away from the autorouter.

That said, they aren't completely useless (though I've never had a case where I needed it), but they are also a very high effort to improve: it's a thorny optimisation problem to start with, but also what is not appreciated is it's also a really difficult user interface problem, since the designer needs to be able to specify the requirements to the autorouter in high precision enough to get a good result, while also taking less time than just doing the routing themselves (which for experienced PCB designers is not really that long for most cases), especially when placement is just as important for a good result, intermingles with routing to a large degree, and is even harder to specify (placement depends on finding a good compromise between thermal, electrical, and mechanical goals, all of which are difficult to specify precisely).

Given they're a big trap to newcomers and also a huge amount of effort for something which has pretty niche applications in practice, I'm not suprised the team behind KiCAD decided it was not worth the effort. If you (or someone else) thinks they can make a more useful one, it's definitely a space where improvements on the current state of tooling can be improved, but don't underestimate the effort involved.

What specifically are most autorouters bad at? My understanding is that most autorouters are simply using bad algorithms and miss optimizations that a human could spot easily. I was recommended to try this autorouter https://www.eremex.com/products/topor/ but I haven't got round to trialling it yet.

>The designer needs to be able to specify the requirements to the autorouter in high precision enough to get a good result, while also taking less time than just doing the routing themselves

Aren't most of those rules the same between projects. Once you have a good setup you're good to go on many projects?

A lot of the routing work is in the placement, setting up components to make the routing as trivial as possible, and the autorouter isn't doing that for you. I don't think it'll do pours either but I haven't used one in years. If it's a simple board with just some power lines and digital signals the auto-router will probably do ok, maybe faster than doing it by hand if you can reuse most of your rules. But if the board is that easy an experienced layout engineer would also make short work of it.

Now what if the board is more complex? You have some sensitive analog signals, high speed digital signals, and some RF stuff that. Do you take the time to set up a room in Altium with special rules for the RF stuff? Make some complicated rules so that the high speed digital would mess up either of the other things I mentioned? Could be done, but the trial and error of getting all the design rules right is probably more work than just doing it.

The problem is that easy stuff is easy, and doesn't need an autorouter. Hard stuff is still hard with the autorouter and unlikely to save that much time. It's hard to find a use case where you come out ahead. Maybe a board with a massive amount of GPIO and nothing else?

Back when I used Eagle the "oh boy that's so many pins of signals I care so little about" was pretty much the only time I found their autorouter somewhat useful. The remainder of the time I was annoyed because Eagle being essentially just a vector-drawing program doesn't have (or didn't, at the time) push & shove routing which made tweaking layouts so goddarn annoying, in particular because the tools to move stuff around were completely trivial (i.e. they just moved the selected vertices and made no adjustments at all). KiCad is imho way better in almost every way than Eagle (in the versions I am familiar with).

I had that with the autorouter. I was doing a board that had one critical area, a custom switching power supply. The rest was slow signals. The switcher area had to be given a little extra space and some obstacles so the autorouter would do a tight job there. For the rest, whatever the autorouter did was fine.

I, too, am amused by how wound up some people get about this. It's a tool.

Autorouters are generally bad at: routing related signals together (often important for performance), routing power (especially high current traces), prioritising sensitive signals, keeping sensitive signals away from noise ones, and often somewhat suprisingly coming up with any solution at all or coming up with a solution that passes the tool's own design rule checks. Some of this is bad algorithms but a lot of it is because the autorouter is not given enough information. You can specify some of this to most autorouters but it's not super easy, and that information does usually change between projects. That's part of why I think improving the state of the art is in large part a UI problem.

Another big part of why the autorouter might underperform is it's entirely subject to where you've put the components, whereas a human will generally do placement and routing in parallel to at least some extent. Placement is if anything the harder problem in PCB design and there's no systems currently that really combine the two operations (there are auto-placers but they're generally even worse than autorouters, for similar reasons of the requirements are complex and hard to specify).

In general these kinds of systems run into a bit of a catch 22: in order to use them well you need to have enough experience to do the job yourself, and be able to effectively evaluate the output. But when you have this you find it's faster and easier to do it yourself. And expecting it to be helpful for beginners is a bit like expecting github's copilot to be a shortcut for beginners: the tool is going to throw out bad results sometimes and the beginner is not going to be able to evaluate that or know how to fix it.

Like I said, I think there's room for improvement here, both in terms of interface and in terms of algorithms. But it's far from non-trivial. As for TopoR, it does look like one of the better options, and I really like that it's challenging the 45 degree orthodoxy which is basically a relic from limitations of early PCB CAD which is sadly still solidified in the tools (even in a modern PCB CAD tool it's hard to route something at an arbitrary angle, and it tends to break routing features like push-and-shove), but I haven't had a situation where I've been looking to try it myself (part of this is PCB routing takes up a relatively small portion of my time: if I spent 70% of my time doing it like some specialists I would definitely be spending more time trying to optimise it. As it is it's about 20% of time I spend designing PCBs and I spend less than half my time at work designing PCBs).

I really like the flowing, organic layouts of 60s and 70s PCBs, they are unfortunately very difficult and high maintenance to recreate in modern CAD tools compared to their brutalist brethren. OTOH it's not like anyone will really see the works...

Related: https://www.youtube.com/watch?v=euJgtLcWWyo

Routing tracks on PCBs. They suck at it.

The real problem that needs to be solved is automatically placing the components optimally, not routing the PCB. Routing the PCB is just colouring in.

I suspect that to a professional circuit layout engineer having the machine route traces evokes the same feeling as having gethub copilot write your code does to the professional software engineer.

> They mention a host of things that the autorouters are bad at as evidence that autorouters are useless, instead of recognizing the opportunity to improve autorouters to make their jobs easier.

When a bunch of professionals say that something is useless, pehaps you should pay attention?

The problem is that most PCB boards are extremely constrained routing environments. The boards that KiCad is used to design are extremely so. Vias go completely through the board. Even worse, vias tend to be larger than tracks. Consequently, changing a layer is expensive and introduces more obstacles. Your subcircuit part is also an obstacle on your routing layer. And, generally, you only get 2 "routing" layers (top and bottom) since the other two layers are used to route power and ground.

There is a reason why boards that have FPGAs on them tend to use blind vias which don't penetrate the whole board--they can't route to the balls otherwise. They also tend to be 8+ layer boards. This represents real money and if people could do otherwise (either by hand or autorouter), they would.

However, let's back this out to somewhere that "autorouters" are actually useful--VLSI. As someone who has done VLSI design for a very long time, I can pinpoint the moment when VLSI autorouters went from useless to useful--when metal layer counts hit 4+ layers (local connect, horizontal connect, vertical connect, and power layer).

VLSI does not have the same obstacle issues that PCBs have. Vias only go layer to layer unless you design otherwise. Vias also are smaller than tracks. Consequently, you can practically guarantee that you can interconnect things with enough space. Your subcircuit doesn't also interfere with one of your routing layers. And VLSI design has a LOT more money to throw at developing autorouters.

Even so, VLSI autorouting and placement still looks like crap 25 years on. Nobody has yet been able to come up with an autorouter that can identify a datapath and lay things out in a coherent fashion. And there is good money in doing so.

People like you then come along and are suggesting that the KiCad developers spend a lot of time, on a known very hard computational problem, that people failed horribly to solve in the past with a lot more money and will likely only work well on a minority of expensive PCB boards (8+ layers with blind/buried via).

Color me unsurprised when the responses are less than hospitable.

> They mention a host of things that the autorouters are bad at as evidence that autorouters are useless, instead of recognizing the opportunity to improve autorouters to make their jobs easier.

Sounds like a job for DL! No, really, I'm serious.

If you can feed in enough existing layouts, and give the inputs enough information in terms of what signals are differential pairs, what is the intended impedance, what is high-speed, etc. it might be possible to have a system learn how to do this.

I'd think there's enough gerbers and such laying around the Internet from reference designs to have a big enough data set.

Free business idea for anyone who wants to disrupt the EDA market...

There's some psychological effect where people always look for a more professional approach. You see it in software with design patterns and "antipatterns". Autorouting has been declared an antipattern in electronics, because for professional hardware, it isn't useful. However, hobbyists have radically different needs than professionals. There's an entire class of hobbyist electrical engineering - retrocomputer electronics - where an autorouter is essential (old computers used wide but slow busses, so routing 50-100 traces across a pcb is what matters, signal integrity does not).

> There's an entire class of hobbyist electrical engineering - retrocomputer electronics - where an autorouter is essential (old computers used wide but slow busses, so routing 50-100 traces across a pcb is what matters, signal integrity does not).

You can get away with murder at 1MHz if your trace length isn't too bad but you absolutely do need to worry about signal integrity over that speed or large boards.

When I was a beginner starting out with 65C02's my autorouted boards would work fine around 1MHz but it was impossible to get them working at all at 10MHz until I rerouted the board by hand taking care to think about signal integrity, current return path etc.

In my experience, you can get away with a lot up to 10-25MHz. Mostly just proper board stackup (the bare minimum ensurance that all signal traces are on a layer that's next to a solid ground plane layer, with no slots or cutouts under the traces).

Things like trace length, reflections, power dips when the bus is all 1's, electro and/or magnetic crosstalk, etc. become an issue at around 50MHz, although I've never gone that high in a hobbyist design...