# Freerouting: PCB autorouter for any tool that exports Specctra .dsn files

> Freerouting is a GPL-3.0 Java autorouter for printed circuit board design that reads Specctra .dsn files and writes .ses session files, working with any EDA application that exports the Specctra or Electra DSN format. Three interfaces cover the same routing engine: a GUI, a command-line interface, and a self-hosted or public REST API.

**freerouting/freerouting** — Advanced PCB auto-router

- Repository: https://github.com/freerouting/freerouting
- Website: https://www.freerouting.app
- Stars: 2,079 · Forks: 334
- Language: Java
- License: GPL-3.0
- Published: 2026-10-11 · Updated: 2026-10-11 · Language: en
- Canonical page: https://hysenlabs.com/projects/freerouting-freerouting

## .dsn input and .ses output: the Specctra/Electra interface defines what Freerouting accepts

Freerouting is a Java autorouter for printed circuit board design. Its scope is defined by the exchange format it speaks: Specctra or Electra DSN. Any PCB design application that exports a .dsn file can hand routing work to Freerouting, and Freerouting writes back a .ses session file that the same application imports to apply the routed connections.

This file-based round-trip is both the project's reach and its constraint. Freerouting cannot open native project files from KiCad, Autodesk Fusion or any other EDA tool directly. Every routing session requires exporting .dsn from the source tool, running Freerouting, then re-importing the resulting .ses. Documented integrations exist for KiCad, Autodesk Fusion, Target3001!, EasyEDA, tscircuit and pcb-rnd, each handling the export and re-import steps. Details for all six are in docs/integrations.md.

Routing can run for a few minutes or several hours, according to the README, depending on board complexity. Freerouting attempts to route all unconnected nets in the imported design and runs multiple passes until no further progress is made or the routing is complete.

## Opening a .dsn and clicking the Magic Wand icon covers the core GUI workflow

Opening a .dsn file via File > Open and clicking the Magic Wand icon are the two user actions that start the GUI routing process. Freerouting then runs passes autonomously, and waiting for all passes to complete is what the README recommends before saving. Progress is visible both graphically in the board editor and numerically in a footer counter that updates as nets get routed.

Routing time ranges from a few minutes to several hours with no further guidance in the README on which factors drive the difference. For long jobs, the footer counter is the practical indicator of whether a run is proceeding normally.

One explicit platform restriction applies. macOS users must launch Freerouting from the Terminal; Finder launching is documented as unsupported, even though the application presents a graphical interface. Windows and Linux have standard installers for x64 systems. For other architectures, the platform-independent .jar works when a Java JRE is installed.

Saving the routed result uses File > Save as with a .ses extension, after which the file is ready for re-import into the originating EDA tool.

## Five CLI flags cover batch routing; -inc skips net classes like GND and VCC

Five documented flags cover the core CLI use. -de takes the .dsn input path, -do specifies where to write the .ses output, -l sets the display language (en and de are the given examples), -inc lists net class names to exclude from routing, and -help prints available options. Additional detail on headless mode is in docs/command_line_arguments.md rather than in the README.

```bash
java -jar path/to/freerouting.jar -de MyBoard.dsn -do MyBoard.ses -inc GND,VCC
```

Substitute the actual path to the downloaded .jar for the placeholder. Passing GND,VCC to -inc keeps those nets out of the routing pass because power and ground nets are typically filled by copper pours rather than individual traces; routing them would produce a result that conflicts with the design intent.

All three interfaces (GUI, CLI and API) accept the same command-line arguments for input and output file paths and settings adjustments. Headless mode runs without launching the GUI and is suitable for scripted or automated board routing.

## The self-hosted API exposes port 37864; the public endpoint is beta and requires requesting access

Freerouting exposes a REST API for programmatic routing. The README explicitly marks the API and its documentation in docs/API/ as beta: endpoints and request formats may change. Access to the public endpoint requires requesting credentials through the Freerouting website before full functionality is available.

Self-hosting the API uses Docker. Dockerfile exposes port 37864 and the default container command runs with --api_server-enabled=true and --gui-enabled=false, running the API server without the graphical interface. A Docker volume at /mnt/freerouting provides writable storage. Full self-hosting steps are in docs/self-hosting.md.

An official Python client is in the freerouting-python-client repository. Installing it takes one command:

```bash
pip install freerouting-client
```

For JavaScript, C# and C++, the repository provides OpenAPI-based SDK generation scripts under scripts/sdk/. Running scripts/sdk/regenerate-all.ps1 refreshes all three scaffolds in one command.

Using the Docker image on port 37864 as a self-hosted server avoids the public API access requirement and keeps routing local, which is relevant for any workflow where board data must not leave the building.

## MCP support routes boards via npx for AI coding assistants without a local Java install

MCP support targets workflows where an AI coding assistant drives the routing process. Cursor, Cline and Claude Desktop are named as compatible assistants. Two deployment modes are available.

Online mode requires no local Java installation. Running this command starts the MCP server:

```bash
npx -y @freerouting/freerouting-mcp-server
```

This fetches the latest MCP server package from npm and connects to the public Freerouting API. Board data leaves the local machine in this mode, which is the relevant trade-off for teams with data locality requirements.

Offline mode runs the entire routing engine locally, keeping board data on the same machine. Configuration for both modes is in docs/API/MCP.md. That file is separate from the main README, so the setup steps are not visible in the repository's default landing page.

The MCP server exposes two capabilities to the AI assistant: querying routing system status and submitting routing jobs. Getting the online mode to work requires API credentials obtained through the Freerouting website, since the public API has an access-request step.

## src_v19/ is excluded from codespell in pyproject.toml while src/ is the active codebase

Both src/ and src_v19/ appear at the repository's top level. Nothing in the README explains src_v19 or relates it to the current codebase, but pyproject.toml at the repository root is explicit. That file configures codespell and includes src_v19 in the skip parameter alongside generated files, binary assets and fixture data. Code in src/ participates in the spellcheck pass; src_v19 does not.

By its name, its exclusion from tooling, and the absence of any README mention, src_v19 holds an older engine that the project retains as a historical reference. Developers contributing to the routing algorithm should treat src/ as the active code and src_v19 as background material.

Another aspect of the build is documented in the Dockerfile comments rather than in the README. When building a linux/arm64 image under QEMU emulation for cross-platform support, unit tests are intentionally skipped. The Dockerfile comment explains that the tests need a functional loopback network interface that QEMU does not reliably provide. Tests run on the native CI runner before the cross-platform image build, so the Dockerfile skip is a build environment limitation, not a gap in test coverage.

## Java 25 JRE is required for the platform-independent JAR; Gradle builds the executable

For platforms without a native installer, the README directs users to adoptium.net to download a Java JRE, specifying to select the JRE package type and Java 25 as the runtime. Both the Dockerfile build stage (eclipse-temurin:25-jdk-jammy) and the runtime stage (eclipse-temurin:25-jre-jammy) use the same runtime, confirming that Java 25 is the supported baseline.

Building from source uses Gradle, indicated by build.gradle, settings.gradle and gradlew at the repository root. Gradle produces freerouting-current-executable.jar, which the Docker runtime stage copies in as freerouting-executable.jar for container deployment.

An examples/tutorial_board/ directory at the repository root provides sample board files. These give a concrete .dsn to test against either the GUI or the CLI before connecting a real project.

v2.5.0 arrived on 2026-10-05 and the last push was on 2026-10-06 under a GPL-3.0 licence; distributing a modified build requires including the corresponding source code under those terms.

## Conclusion

Freerouting is appropriate for PCB designers who work with KiCad, Autodesk Fusion, EasyEDA or any other tool that exports Specctra .dsn files, and who want an autorouter they can run locally or call as an API service. Users who need routing integrated directly into their EDA environment without a .dsn export step should stay with their native router. Before adopting the API path, verify whether the current endpoints in docs/API/ fit your workflow, since the README marks the API as beta, and confirm whether the public service or a self-hosted Docker deployment on port 37864 is more appropriate.

## FAQ

### How does Freerouting integrate with KiCad?

KiCad is listed as one of the documented integrations in docs/integrations.md. The pattern is the same as for other tools: export a .dsn file from KiCad, route it in Freerouting, then re-import the resulting .ses session file into KiCad.

### Can I run Freerouting without a graphical interface?

Yes. The CLI accepts -de for the .dsn input file and -do for the .ses output path. The Docker container is also configured to run with --gui-enabled=false by default, starting only the API server.

### What is the Freerouting API and how do I access it?

Freerouting exposes a REST API documented in docs/API/. The README marks it as beta and notes it may change. Full access to the public endpoint requires requesting credentials on the Freerouting website; a self-hosted option on port 37864 is documented in docs/self-hosting.md.

### Does Freerouting have a Python SDK?

An official Python client is in the freerouting-python-client repository, installable with pip install freerouting-client. SDK scaffolding scripts for JavaScript, C# and C++ are available under scripts/sdk/ in the main repository.

### What file formats does Freerouting read and write?

Freerouting reads Specctra .dsn files and writes Specctra .ses session files. It works with any PCB design application that supports the standard Specctra or Electra DSN interface for import and export.

## Sources

- [freerouting/freerouting on GitHub](https://github.com/freerouting/freerouting)
- [License: GPL-3.0](https://github.com/freerouting/freerouting/blob/master/LICENSE)
- [Project website](https://www.freerouting.app)
- [README](https://github.com/freerouting/freerouting/blob/master/README.md)
- [Releases](https://github.com/freerouting/freerouting/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/freerouting-freerouting