Test board

RouteAI

LLM-Powered Electronic Design Automation Platform for PCB Design

Download & Install | Features | Architecture | Getting Started | Development | Deployment | License

Overview

RouteAI is an intelligent EDA platform that combines large language models with deterministic solvers to automate and assist PCB (Printed Circuit Board) design workflows. It bridges the gap between human design intent and physical constraints by using LLMs for natural language understanding and expert-grade analysis, while relying on formal solvers for all geometric, electrical, and manufacturing computations.

Key Principle: LLMs handle intent interpretation and design review. Deterministic solvers handle all mathematical operations — coordinates, clearances, impedances, and routing are never generated by AI.

Download & Install

Windows (5 minutes)

Step 1 — Download the installer

Go to https://github.com/Guiimartinho/routeai/releases and download RouteAI-EDA-Setup-x.x.x.exe.

Step 2 — Run the installer

Double-click the .exe. The installer will:

• Install RouteAI EDA to C:\Program Files\RouteAI EDA\
• Create Desktop and Start Menu shortcuts
• Optionally open the Ollama download page
• Optionally add RouteAI to your PATH

Step 3 — Install Ollama (required for AI features)

1. Download from ollama.com/download
2. Run the Ollama installer (next, next, finish)
3. Open a terminal (PowerShell or CMD) and run:

ollama pull qwen2.5:7b

This downloads the AI model (~5GB). Only needed once.

Step 4 — Open RouteAI

Click the "RouteAI EDA" shortcut on your Desktop. Done.

Or use the one-line installer (PowerShell, admin):

irm https://raw.githubusercontent.com/Guiimartinho/routeai/main/scripts/install-windows.ps1 | iex

Linux (5 minutes)

Option A — One-line install (Ubuntu/Debian)

curl -fsSL https://raw.githubusercontent.com/Guiimartinho/routeai/main/scripts/install-linux.sh | bash

This automatically: downloads the .deb, installs it, installs Ollama, pulls the AI model, and launches RouteAI.

Option B — Manual install

# 1. Download the package from GitHub Releases
wget https://github.com/Guiimartinho/routeai/releases/latest/download/RouteAI-EDA-amd64.deb

# 2. Install
sudo dpkg -i RouteAI-EDA-amd64.deb

# 3. Install Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# 4. Pull the AI model
ollama pull qwen2.5:7b

# 5. Launch
routeai-eda

Option C — AppImage (any distro)

wget https://github.com/Guiimartinho/routeai/releases/latest/download/RouteAI-EDA-x86_64.AppImage
chmod +x RouteAI-EDA-x86_64.AppImage
./RouteAI-EDA-x86_64.AppImage

What you need vs. what's included

GPU Recommendations

From Source (Development)

git clone https://github.com/Guiimartinho/routeai.git
cd routeai
./scripts/setup-dev.sh

This installs all dependencies (Python, Node, Go, Ollama) and starts all services. See Getting Started for details.

Features

Design Analysis & Review

• AI-Powered Design Review — Automated PCB analysis with actionable recommendations following IPC standards
• 3-Gate Validation Pipeline — Schema validation, confidence scoring, and citation checking for all LLM outputs
• Schematic Review — Circuit topology analysis, component selection validation, and net connectivity checks

Multi-Format Support

• KiCad — Full import/export for .kicad_pcb and .kicad_sch files
• Eagle — Full import/export for .brd and .sch files
• Gerber/Excellon — Manufacturing output generation

Routing Engine

• A* Pathfinding — Heuristic-based trace routing
• Lee Router — Breadth-first search for guaranteed completion
• Differential Pair Routing — Matched impedance pair routing
• Length Matching — Trace equalization for high-speed buses
• Rip-up and Reroute — Iterative optimization for congested boards
• Global Routing — Multi-net simultaneous routing

Signal & Power Integrity

• Impedance Calculation — Microstrip, stripline, and coplanar waveguide
• Crosstalk Analysis — Near-end and far-end coupling estimation
• Thermal Simulation — Component and copper thermal analysis
• IR Drop Analysis — Power distribution network verification
• Return Path Analysis — Signal integrity validation

Manufacturing

• DRC Engine — 50+ design rule checks (geometric, electrical, manufacturing)
• IPC Compliance — Automated IPC-2221/IPC-7351 verification
• DFM Analysis — Design-for-manufacturing validation
• BOM Export — Bill of materials generation
• Gerber Generation — Production-ready output files
• Pick & Place — Assembly data export

Component Intelligence

• Unified Component Search — Cross-source search across KiCad, Eagle, SnapEDA, LCSC, and EasyEDA libraries
• RAG Pipeline — Retrieval-augmented generation from IPC standards, datasheets, and design guidelines
• 17,000+ Indexed Components — Pre-built component library with symbols and footprints

Collaboration & Integration

• Real-Time Collaboration — WebSocket-based multi-user editing
• KiCad Plugin — Direct integration with KiCad 8 PCB editor
• Version Control — Built-in Git support for design versioning
• Air-Gapped Mode — Fully offline deployment with local LLM (Ollama)

Architecture

┌─────────────────────────────────────────────────────────────────────┐
│                         Client Layer                                │
│  ┌──────────┐  ┌──────────────┐  ┌───────────┐  ┌──────────────┐  │
│  │ Web App  │  │ Desktop App  │  │    CLI    │  │ KiCad Plugin │  │
│  │ (React)  │  │ (Electron)   │  │ (Python)  │  │  (Python)    │  │
│  └────┬─────┘  └──────┬───────┘  └─────┬─────┘  └──────┬───────┘  │
└───────┼────────────────┼────────────────┼───────────────┼──────────┘
        │                │                │               │
        └────────────────┴───────┬────────┴───────────────┘
                                 │ REST / WebSocket
┌────────────────────────────────┼───────────────────────────────────┐
│                         API Gateway (Go/Gin)                       │
│                         Port 8080                                  │
│  ┌──────────┐  ┌───────────┐  ┌───────────┐  ┌────────────────┐  │
│  │   Auth   │  │  Projects │  │ WebSocket │  │  Rate Limiter  │  │
│  │  (JWT)   │  │  Manager  │  │    Hub    │  │   Middleware   │  │
│  └──────────┘  └───────────┘  └───────────┘  └────────────────┘  │
└──────────┬──────────────────────────┬─────────────────────────────┘
           │                          │
     ┌─────┴─────┐             ┌──────┴──────┐
     │ ML Service │             │   Router    │
     │ (FastAPI)  │             │   (gRPC)    │
     │ Port 8001  │             │ Port 50051  │
     └─────┬──────┘             └──────┬──────┘

Tech Stack

Project Structure

routeai/
├── packages/
│   ├── core/              # Unified PCB data model (Pydantic v2)
│   ├── parsers/           # KiCad/Eagle file parsers and exporters
│   ├── intelligence/      # LLM agents, RAG pipeline, validation
│   ├── solver/            # DRC engine, SI/PI analysis, Z3 constraints
│   ├── api/               # Go API gateway (Gin + JWT + WebSocket)
│   ├── router/            # C++17 routing engine (A*, Lee, diff pair)
│   ├── web/               # React frontend (Three.js, Zustand)
│   ├── cli/               # Command-line interface (Click + Rich)
│   └── kicad-plugin/      # KiCad 8 editor integration
├── app/                   # Electron desktop application
├── infrastructure/
│   ├── docker/            # Dockerfiles for all services
│   ├── k8s/               # Kubernetes manifests
│   ├── monitoring/        # Prometheus + Grafana configs
│   └── air-gapped/        # Offline deployment setup
├── scripts/               # Setup, seeding, and benchmark scripts
├── data/
│   ├── component_library/ # Pre-indexed KiCad component data
│   ├── ipc_standards/     # IPC reference documents
│   ├── benchmarks/        # Performance test data
│   └── reference_designs/ # Sample PCB designs
├── .github/workflows/     # CI/CD pipeline

Getting Started

Prerequisites

• Python 3.11+ with Poetry
• Go 1.22+
• Node.js 18+ with npm
• Docker and Docker Compose
• CMake 3.20+ and Conan (for C++ routing engine)

GPU Requirements

RouteAI runs LLM inference locally via Ollama. No cloud APIs required.

Run the setup script to auto-detect your GPU and pull the right models:

./scripts/setup_ollama.sh

Quick Start

1. Clone the repository

git clone git@github.com:Guiimartinho/routeai.git
cd routeai

2. Start infrastructure services

make dev

This starts PostgreSQL (port 5432), Redis (port 6379), and MinIO (ports 9000/9001).

3. Install Python packages

for pkg in core parsers solver intelligence cli; do
  cd packages/$pkg && poetry install && cd ../..
done

4. Build and run the API gateway

cd packages/api
go build -o routeai-api .
./routeai-api

The API will be available at http://localhost:8080.

5. Start the ML service

cd packages/intelligence
poetry run uvicorn routeai_intelligence.ml_service:app --host 0.0.0.0 --port 8001

6. Start the web frontend

cd packages/web
npm install
npm run dev

The web app will be available at http://localhost:5173.

Environment Variables

Create a .env file in the project root:

# Database
POSTGRES_HOST=localhost
POSTGRES_PORT=5432
POSTGRES_USER=routeai
POSTGRES_PASSWORD=routeai_dev
POSTGRES_DB=routeai

# Storage
MINIO_ENDPOINT=localhost:9000
MINIO_ACCESS_KEY=minioadmin
MINIO_SECRET_KEY=minioadmin

# LLM Provider (local Ollama — run ./scripts/setup_ollama.sh first)
OLLAMA_BASE_URL=http://localhost:11434

# JWT
JWT_SECRET=your-jwt-secret

Development

Commands

make dev              # Start development infrastructure
make dev-down         # Stop infrastructure services
make test             # Run all package tests
make test-core        # Test core package
make test-parsers     # Test parsers package
make test-intelligence# Test intelligence package
make test-solver      # Test solver package
make test-cli         # Test CLI package
make test-cov         # Run tests with coverage
make lint             # Run ruff + mypy on all packages
make lint-fix         # Auto-fix linting issues
make format           # Format code with ruff
make benchmark        # Run performance benchmarks
make clean            # Remove build artifacts

Code Quality

Coverage Targets

Building the C++ Router

cd packages/router
mkdir build && cd build
conan install .. --build=missing
cmake .. -DCMAKE_BUILD_TYPE=Release
cmake --build . -j$(nproc)

Building the Desktop App

cd app
npm install
npm run electron:build          # All platforms
npm run electron:build:win      # Windows
npm run electron:build:linux    # Linux

Building Installers

# Build Windows installer (.exe)
./scripts/build-installer.sh windows

# Build Linux packages (AppImage + .deb)
./scripts/build-installer.sh linux

# Build all platforms
./scripts/build-installer.sh all

Output files are in app/release/.

Deployment

Docker Compose (Production)

docker-compose -f docker-compose.prod.yml up -d

Kubernetes

kubectl apply -f infrastructure/k8s/namespace.yaml
kubectl apply -f infrastructure/k8s/

Air-Gapped (Offline)

For secure environments without internet access:

cd infrastructure/air-gapped
docker-compose -f docker-compose.airgap.yml up -d

This deployment uses local Ollama models (Mistral, LLaMA 3.1) instead of cloud APIs.

API Reference

The API gateway exposes the following endpoint groups:

Screenshots

Contributing

1. Fork the repository
2. Create a feature branch (git checkout -b feature/your-feature)
3. Ensure tests pass (make test)
4. Ensure linting passes (make lint)
5. Submit a pull request

All new code must include tests and maintain the established coverage targets.

License

This project is licensed under the MIT License. See individual package files for details.

RouteAI — Intelligent PCB Design, Powered by AI.