KiCad ships a capable interactive router, a stackup editor and length tuning — but it has never included an autorouter. When people ask how to autoroute a KiCad board, the answer is almost always the same tool: Freerouting, a free external autorouter you feed with a file and read back a file. Here's how the workflow actually works today, and — just as important — when you shouldn't reach for it.
Short answer: KiCad has no built-in autorouter. Freerouting is the standard free, open-source option: you export a Specctra DSN file from KiCad, route it in Freerouting, then import the resulting SES file back. It's genuinely useful for simple boards and bulk non-critical nets, but experienced designers still route critical nets by hand — and KiCad's own interactive push-and-shove router is often the better tool.
Why KiCad has no built-in autorouter
This is a deliberate design choice, not an oversight. Good autorouting is a hard, specialized problem, and the KiCad team has focused its effort on the interactive router — push-and-shove, length and delay tuning, differential pairs — because that's where most professional layout work actually happens. Rather than ship a mediocre built-in autorouter, KiCad exposes the industry-standard Specctra DSN/SES interface so you can plug in whichever external router you like. Freerouting is the one nearly everyone uses.
What Freerouting is
Freerouting is an advanced autorouter for any PCB program that speaks the Specctra or Electra DSN interface. A few facts worth knowing before you install it:
- It's open-source under the GPL-3.0 license — free for any use, including commercial hardware.
- It's a Java application, so you need a Java runtime installed (the project currently recommends Java 25, but the platform-independent
.jarruns on any compatible JRE). Native installers exist for Windows, macOS and Linux. - The current release is 2.2.4, and recent versions added a public API, a command-line mode and a Python SDK for scripted/automated routing — useful if you want to drive it headlessly rather than through its GUI.
Note there is no official Freerouting plugin inside KiCad's Plugin and Content Manager. Some community launcher plugins exist that add a "FreeRouting" entry under Tools → External Plugins to automate the export/launch, but the core, reliable path is the manual DSN → route → SES cycle below.
The step-by-step workflow
Do all of your component placement first — Freerouting routes what you place, it won't place parts for you. Then:
- Export the DSN. In the PCB editor, go to File → Export → Specctra DSN. This writes a
.dsnfile describing your board outline, pads, netlist and design rules. - Open it in Freerouting. Launch Freerouting (run the installer, or
java -jar freerouting.jar) and open the.dsnfile you just exported. - Autoroute. Click the autorouter button in the toolbar. Freerouting works net by net, ripping up and retrying as it goes. On a small board it's seconds; on a dense one it can churn for a while, and you can stop it once the pass count stops improving.
- Export the session. When you're happy, use File → Export Specctra Session File to write a
.sesfile with the routing result. - Import back into KiCad. With your original board still open, go to File → Import → Specctra Session and select the
.ses. KiCad deletes existing tracks/vias and rebuilds them from the session. Save.
If the result isn't good, don't fight it in place — use Edit → Global Deletions, check Tracks & Vias, and start over with different rules.
Set your rules before you route, not after
The single biggest determinant of autoroute quality is the constraints you hand it. Freerouting only knows what your DSN tells it, so configure this in KiCad first:
- Net classes with sensible trace widths and clearances — a wider, higher-clearance class for power and a default class for signals is the minimum. See net classes and design rules in KiCad.
- Via sizes and, if relevant, which layers are available for routing.
- Board-level clearances in the Board Setup so the exported rules match what your fab can build.
Set these thoughtfully and the autorouter produces something you can actually keep. Leave everything at defaults and you'll get hair-thin traces snaking all over the board.
When to autoroute — and when to route by hand
This is where honesty matters. Autorouting is a tool with a narrow sweet spot, not a "route my board" button. The consensus among working PCB designers is a hybrid approach: hand-route the nets that matter, autoroute the rest, or use the autoroute as a rough first pass you then rework.
| Good fit for autorouting | Route by hand |
|---|---|
| Simple 2-layer boards, breakouts, adapters | High-speed digital (DDR, USB, Ethernet, differential pairs) |
| Dense but non-critical bulk connections | RF and sensitive analog nets |
| Prototypes and quick "does it fit?" passes | Power and ground — width, planes, return paths |
| Fanning out a big connector or IO field | Anything needing controlled impedance or length matching |
| A starting point you'll clean up manually | Boards where EMC/thermal performance is critical |
The reasoning is straightforward: an autorouter optimizes for making connections, not for the electrical intent behind them. It doesn't know a ground path should be short and wide, or that a high-speed trace wants as few vias as possible. For those nets, KiCad's interactive router — with length tuning and push-and-shove — gives you control the autorouter simply can't. Many designers route the critical 10–20% of nets first, lock them, then let Freerouting fill in the rest.
Clean up and run DRC afterward
Treat autorouted output as a draft, not a finished board. After importing the SES:
- Run DRC and fix everything it flags — see fixing common KiCad DRC errors. Freerouting tries to respect your rules, but SES import can still surface clearance or unconnected-net issues.
- Eyeball the critical nets. Rework anything the autorouter did that offends your electrical intent — awkward via stitching, long ground returns, needless detours.
- Re-pour copper zones and confirm your planes are intact.
- Confirm net classes survived the round trip and that trace widths match what you specified.
An autoroute that passes DRC still isn't automatically a good layout. The final review is on you.
However you route — Freerouting for a first pass, or every trace by hand — the tedious part usually isn't the routing itself, it's regenerating the manufacturing package every time you iterate. For KiCad projects, GoForFab handles that automatically: every push regenerates the full set of outputs — Gerbers, drill files, BOM, CPL, DRC/ERC reports, 3D renders — free forever. So you can rip up a routing pass, try another, and never manually re-export a thing.
Sources: Freerouting — Using with KiCad, Freerouting on GitHub, Freerouting.app, Autorouting in KiCad using the Freerouting plugin (Sierra Circuits)