KiKit: Stop Wasting Hours on KiCAD Panelization

What if every PCB panel you created took 30 seconds instead of 3 hours?

Picture this: It's 11 PM. Your board design is finally perfect. The schematic is clean, the layout passes DRC, and you're ready to send everything to the manufacturer. Then you remember — you need a panel. Ten identical boards, arranged in a 2×5 grid, with mouse bites for separation and proper tooling strips. Your heart sinks. You open Pcbnew, start the tedious "append board" dance, manually align each instance, pray the nets don't collide, and hope you don't have to redo everything when your boss inevitably requests "just one small change" tomorrow morning.

Sound familiar? You're not alone. This soul-crushing workflow has haunted hardware engineers for years. The hidden cost isn't just time — it's error propagation. Every manual panelization step introduces potential net conflicts, misalignments, and DRC failures that slip through to manufacturing. One wrong move, and you're explaining to your project manager why 500 boards arrived with shorted power planes.

Enter KiKit — the open-source automation engine that transforms KiCAD from a manual labor camp into a precision manufacturing pipeline. Created by Jan Mrázek (yaqwsx), KiKit doesn't just speed up panelization; it eliminates the entire category of human error that plagues hand-crafted panels. Whether you're a solo maker shipping dozens of designs or an engineering team managing complex multi-board products, KiKit is the secret weapon that top PCB designers have already adopted. And if you're still clicking through Pcbnew's append dialog? You're leaving hours on the table every single week.

What is KiKit?

KiKit is a multi-modal automation toolkit for KiCAD that operates as a Python library, command-line interface (CLI) tool, and native KiCAD plugin. Born from the frustration of repetitive PCB workflows, it targets the most time-intensive tasks in hardware development: panelization, manufacturing data export, multi-board project management, and even solder paste stencil generation.

The project is the brainchild of Jan Mrázek, a Czech hardware engineer and prolific open-source contributor in the KiCAD ecosystem. Beyond KiKit, Mrázek maintains PcbDraw (automated PCB rendering), Pinion (interactive board documentation), and JlcParts (JLCPCB component integration) — a portfolio that reveals deep understanding of where KiCAD workflows break down and how to fix them systematically.

KiKit has gained explosive traction because it addresses a critical gap in KiCAD's native capabilities. While KiCAD 7 and 8 have improved significantly, the core philosophy remains manual interaction for complex operations. KiKit inverts this paradigm: define your intent programmatically, execute repeatably, version control your manufacturing pipeline. This approach resonates particularly with teams practicing hardware DevOps, where reproducibility and automation aren't luxuries — they're requirements.

The tool's architecture is deliberately flexible. Need a one-off panel? Use the CLI with a few flags. Building a custom workflow? Import the Python API into your scripts. Want point-and-click convenience? The GUI plugin integrates directly into Pcbnew's interface. This triple threat ensures KiKit adapts to your workflow, not the reverse.

Crucially, KiKit is manufacturer-aware. It ships with presets for major fabricators — JLCPCB, PCBWay, OSH Park, and others — automatically configuring Gerber formats, drill files, and assembly data to match each vendor's exact requirements. No more cross-referencing outdated wiki pages or discovering your Excellon files were rejected at 2 AM.

Key Features That Transform Your Workflow

KiKit's feature set reads like a wishlist from engineers who've spent too many nights in Pcbnew. Here's what separates it from cobbled-together scripts or manual methods:

Intelligent Panelization Engine KiKit handles both regular rectangular boards and arbitrarily shaped designs — think circular IoT sensors, hexagonal LED tiles, or organic wearable PCBs. The engine places boards via explicit coordinates or automatic grid arrangements, adds bridges (tabs) of substrate material between instances, and generates mouse bites or V-cuts for depanelization. Unlike manual append operations, KiKit ensures distinct net names for each board instance, eliminating the DRC nightmares that plague hand-built panels.

Manufacturing Data Automation One command exports complete manufacturing packages: Gerber RS-274X files, Excellon drill data, IPC-356 netlists, BoM CSVs, and component placement files. The manufacturer presets handle layer naming conventions, file formats, and even special requirements like JLCPCB's assembly rotations or PCBWay's impedance control documentation.

Multi-Board Project Simplification KiCAD's native project structure assumes one board per file. KiKit shatters this limitation, enabling true multi-board products with unified manufacturing data. Split combined designs, manage dependencies, and generate coherent documentation across sub-boards.

Advanced Stencil Generation Beyond standard steel stencils, KiKit pioneered 3D-printed self-registering solder paste stencils — a game-changer for rapid prototyping. The generated STLs include alignment features that mate with PCB fiducials, eliminating frame requirements and reducing stencil cost from $50+ to pennies of filament.

Workflow Integration The CLI enables Makefile-driven builds: make panel generates your array, make fab produces manufacturer files, make docs renders presentation pages. This isn't convenience — it's hardware continuous integration, where your manufacturing artifacts rebuild automatically with every Git commit.

Native GUI Plugin For engineers preferring visual workflows, KiKit's Pcbnew plugin exposes core functionality through familiar dialog boxes, lowering the barrier for team members less comfortable with command lines.

Real-World Use Cases Where KiKit Dominates

High-Volume Production Panels

You're shipping 10,000 sensor nodes. Each panel must hold 6 boards with 2 mm spacing, mouse bites on two edges, and a 5 mm tooling rail with fiducials. Manual creation: 45 minutes, error-prone. KiKit CLI: one command, perfectly repeatable, version-controlled in your repository.

Rapid Prototyping Iteration

Your startup pivots weekly. Every board revision needs new panels for the next batch of 20 test units. With KiKit, your panelize.py script adapts to any board dimensions automatically. Change the design, run the script, send to fab. Iteration cycle: minutes, not hours.

Complex Multi-Shape Arrays

Designing a modular LED wall with hexagonal, triangular, and rectangular tiles in one panel? KiKit's arbitrary shape support and explicit placement API position each piece precisely, handling the substrate bridges and separation methods that would be virtually impossible to construct manually.

Contract Manufacturing Handoff

Your CM demands specific Gerber formats, layer naming, and assembly file structures. KiKit's manufacturer presets encode these requirements, eliminating the back-and-forth emails and rejected file sets that delay production by days.

Hardware DevOps Pipelines

You're running automated tests on physical PCBs. KiKit integrates into your CI system, automatically generating manufacturing data when pull requests merge. The repeatability guarantee means board rev 1.3.2 produces identical panels whether built today or six months from now.

Step-by-Step Installation & Setup Guide

KiKit's installation requires attention to KiCAD's Python environment, which varies by platform. Follow these steps carefully:

Prerequisites

• KiCAD 6.0+ installed (KiKit tracks KiCAD's Python API evolution)
• Python 3.7+ (specific interpreter requirements below)
• pip package manager

Platform-Specific Installation

Windows (KiCAD 7+):

# KiCAD ships with embedded Python; use it directly
# Open Command Prompt and run:
"C:\Program Files\KiCad\7.0\bin\python.exe" -m pip install kikit

# For KiCAD 8, adjust path accordingly:
"C:\Program Files\KiCad\8.0\bin\python.exe" -m pip install kikit

macOS:

# KiCAD's Python is typically at:
/Applications/KiCad/KiCad.app/Contents/Frameworks/Python.framework/Versions/Current/bin/python3 -m pip install kikit

# Or if using Homebrew KiCAD:
/opt/homebrew/bin/python3 -m pip install kikit  # Apple Silicon
/usr/local/bin/python3 -m pip install kikit      # Intel

Linux (Ubuntu/Debian):

# KiCAD uses system Python; install directly:
sudo apt update
sudo apt install python3-pip
pip3 install kikit

# For KiCAD nightly builds, you may need:
python3 -m pip install --user kikit

Verify Installation

# Check CLI availability
kikit --help

# Expected output: comprehensive command listing including panelize, fab, stencil, etc.

GUI Plugin Setup

After pip installation, enable the plugin in KiCAD:

1. Open Pcbnew
2. Navigate to Tools → External Plugins → Refresh Plugins
3. KiKit panelization actions appear in the Tools menu

Environment Configuration (Recommended)

Create a project Makefile for reproducible builds:

# Makefile for automated PCB manufacturing pipeline
BOARD = myproject.kicad_pcb
PANEL = panel.kicad_pcb
FAB_DIR = fabrication

.PHONY: panel fab clean

panel: $(PANEL)

$(PANEL): $(BOARD)
	kikit panelize grid --space 2 --gridsize 2 3 --tabs full --mousebites 0.5 1 0.25 --radius 1 $(BOARD) $(PANEL)

fab: $(PANEL)
	mkdir -p $(FAB_DIR)
	kikit fab jlcpcb --no-drc $(PANEL) $(FAB_DIR)

clean:
	rm -f $(PANEL)
	rm -rf $(FAB_DIR)

This setup enables make panel && make fab for complete manufacturing output from any clean checkout.

REAL Code Examples from KiKit

KiKit's power emerges in actual implementation. These examples derive directly from the project's documentation and real usage patterns.

Example 1: Basic Grid Panelization (CLI)

The fastest path to production panels uses KiKit's CLI with descriptive flags:

# Create a 2×3 grid panel with 2mm spacing between boards
# --tabs full: generate tabs on all board edges
# --mousebites 0.5 1 0.25: drill diameter 0.5mm, spacing 1mm, offset 0.25mm
# --radius 1: 1mm radius for mouse bite drill holes
# --gridsize 2 3: arrange in 2 columns, 3 rows

kikit panelize grid \
    --space 2 \
    --gridsize 2 3 \
    --tabs full \
    --mousebites 0.5 1 0.25 \
    --radius 1 \
    input_board.kicad_pcb \
    output_panel.kicad_pcb

What's happening here? KiKit reads your source board, instantiates six copies in a grid, adds substrate bridges with mouse bite perforations for depanelization, and writes a fully valid KiCAD PCB file. The --tabs full option automatically determines optimal tab placement based on board geometry — no manual polygon drawing required.

Example 2: Advanced Panel with Python API

For complex arrangements, KiKit's Python API provides surgical control:

#!/usr/bin/env python3
"""
Custom panelization script for irregular board shapes
with explicit placement and mixed separation methods.
"""

from kikit.panelize import Panel, Origin
from kikit.common import toMM
from shapely.geometry import Point  # KiKit uses Shapely for geometric operations

# Initialize panel with substrate properties
panel = Panel()

# Load source board; preserve original nets to avoid DRC conflicts
board_source = "sensor_node.kicad_pcb"

# Place first instance at origin with 0-degree rotation
# addBoard returns the placed board's bounding information
placed1 = panel.addBoard(board_source, 
                         destination=Point(toMM(0), toMM(0)), 
                         rotation=0,
                         origin=Origin.Center)  # use board center as placement anchor

# Place second instance with 90-degree rotation for space optimization
placed2 = panel.addBoard(board_source,
                         destination=Point(toMM(35), toMM(0)),
                         rotation=90,
                         origin=Origin.Center)

# Add substrate bridge between specific points on both boards
# This creates mechanical connection for panel rigidity
panel.addBridge(placed1.area, placed2.area, 
                width=toMM(2),  # 2mm wide bridge
                slotWidth=toMM(0))  # solid bridge, no slotting

# Generate V-cut line between the two boards for clean separation
panel.addVCut(placed1.position.y)

# Add mouse bites on outer edges for depanelization
panel.addMouseBites(placed1.area, 
                    diameter=toMM(0.5),    # 0.5mm drill
                    spacing=toMM(1.0),     # 1mm between holes
                    offset=toMM(0.25),     # 0.25mm from board edge
                    prolongation=toMM(0.5)) # extend bite past corner

# Generate tooling strips with fiducials for assembly alignment
panel.appendSubstrate(toMM(5))  # 5mm tooling rail
panel.addFiducial(toMM(2.5), toMM(2.5), toMM(1))  # global fiducial

# Finalize: merge all elements, resolve net names, validate DRC
panel.save("custom_panel.kicad_pcb")

Critical insight: The Origin.Center parameter ensures consistent placement regardless of board outline complexity. The explicit bridge and V-cut combination demonstrates KiKit's flexibility — use V-cuts for straight edges, mouse bites for irregular perimeters, or hybrid approaches for optimal manufacturing yield.

Example 3: Automated Manufacturing Export

Complete fabrication package generation for JLCPCB:

# Export complete JLCPCB manufacturing package
# --no-drc: skip DRC if board is already validated (speeds CI builds)
# --assembly: generate pick-and-place and BoM for SMT assembly
# --schematic: include schematic PDF for reference

kikit fab jlcpcb \
    --no-drc \
    --assembly \
    --schematic myproject.kicad_sch \
    myproject.kicad_pcb \
    ./jlcpcb_output/

# Resulting directory structure:
# jlcpcb_output/
# ├── gerbers/           # All Gerber RS-274X files with correct extensions
# ├── drill/             # Excellon drill files
# ├── assembly/          # CPL (placement) and BOM files
# ├── schematic.pdf      # Reference schematic
# └── README.txt         # Layer stackup and special instructions

The automation advantage: JLCPCB's specific requirements — .gbr extensions, specific layer names, CPL rotation conventions — are encoded in KiKit's preset. Without this, you'd manually rename layers, verify rotations against JLC's non-standard coordinate system, and risk rejected orders.

Example 4: Multi-Board Project Splitting

# Split combined KiCAD file containing multiple board designs
# into individual projects with proper netlist isolation

kikit separate \
    --source combined_designs.kicad_pcb \
    --outputdir ./boards/ \
    --nametemplate "{boardName}_{index}"

# Generates: boards/sensor_0.kicad_pcb, boards/controller_1.kicad_pcb, etc.
# Each with independent net names and design rule configurations

This solves a genuine KiCAD limitation: the single-board-per-file assumption that complicates product designs with multiple interacting PCBs.

Advanced Usage & Best Practices

Version-Control Your Panelization Scripts Never hardcode parameters in one-off commands. Commit your panelize.py or Makefile alongside PCB files. When design revisions change board dimensions, adjust the script once, regenerate everything consistently.

Leverage Manufacturer Presets for Multi-Vendor Strategy Maintain parallel export configurations for your primary and backup manufacturers. KiKit's preset system makes vendor switching a one-flag change:

kikit fab jlcpcb panel.kicad_pcb ./fab/jlcpcb/
kikit fab pcbway panel.kicad_pcb ./fab/pcbway/  # same panel, different output rules

Optimize Panel Efficiency with Python For production volumes, write optimization scripts that iterate panel arrangements:

# Pseudo-code for finding optimal panel density
best_yield = 0
for cols in range(1, 10):
    for rows in range(1, 10):
        panel = create_panel(cols, rows, board)
        yield = calculate_material_utilization(panel)
        if yield > best_yield and fits_manufacturer_constraints(panel):
            best_yield = yield
            best_config = (cols, rows)

Integrate with CI/CD Pipelines GitHub Actions example for automatic manufacturing data on release tags:

# .github/workflows/manufacturing.yml
name: Generate Manufacturing Data
on:
  push:
    tags: ['v*']
jobs:
  fab:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: pip install kikit
      - run: make panel && make fab
      - uses: actions/upload-artifact@v4
        with:
          name: manufacturing-data
          path: fabrication/

Comparison with Alternatives

Verdict: Manual Pcbnew works for one-off simple rectangles but collapses under repetition or complexity. GerberPanelizer operates on finished Gerbers, losing KiCAD's design intelligence. Custom scripts replicate KiKit's functionality poorly and become maintenance burdens. KiKit occupies the sweet spot of power, maintainability, and ecosystem integration.

Frequently Asked Questions

Does KiKit work with KiCAD 8? Yes, KiKit actively tracks KiCAD releases. Check the installation guide for version-specific Python interpreter paths, as KiCAD's embedded Python location changes between major versions.

Can I panelize boards with complex cutouts and non-rectangular shapes? Absolutely. KiKit's Shapely-based geometry engine handles arbitrary board outlines including internal cutouts, curved edges, and complex polygons. The panelization algorithm automatically computes valid tab placements and substrate regions.

Is KiKit free for commercial use? KiKit is released under the MIT License, permitting unrestricted commercial use, modification, and distribution. Consider sponsoring Jan Mrázek via GitHub Sponsors to ensure continued development.

How do I handle boards with different designs in one panel? Use the Python API's addBoard() method multiple times with different source files, or the CLI's upcoming multi-source features. Position each design explicitly via coordinates for mixed-product panels.

What if my manufacturer isn't in KiKit's preset list? Presets are JSON-configurable. Copy an existing preset, modify layer mappings and file extensions, and contribute back via pull request. The community actively expands manufacturer coverage.

Does KiKit support panel-level DRC? Yes, and this is crucial — KiKit generates panels where each board instance has distinct net names (e.g., GND_1, GND_2), preventing the false short-circuit errors that plague manually appended boards. Run standard KiCAD DRC on generated panels with confidence.

Can I use KiKit without learning Python? The CLI and GUI plugin cover 80% of use cases without code. Python scripting becomes valuable for complex arrangements, parametric designs, or CI integration — but isn't mandatory for productivity gains.

Conclusion

KiKit isn't merely a convenience tool — it's a fundamental workflow upgrade that transforms PCB manufacturing from artisanal craft to engineered process. The hours reclaimed from manual panelization compound across every design iteration, every production run, every team member onboarded. More critically, the repeatability guarantee eliminates an entire class of manufacturing defects born from human inconsistency.

The hardware industry is awakening to automation. While software teams have enjoyed CI/CD pipelines for decades, PCB workflows have languished in manual inefficiency. KiKit bridges this gap, bringing hardware development into modern engineering practice without sacrificing the creative control that makes hardware design rewarding.

If you're currently clicking through Pcbnew's append dialog, stop. That time is irretrievable, and the errors are inevitable. Install KiKit today, script your first panel, and experience the visceral satisfaction of make fab producing perfect manufacturing data while you grab coffee.

Ready to automate? Grab KiKit from the official repository, explore the comprehensive documentation, and join the growing community of engineers who've escaped panelization purgatory. Your future self — the one not debugging net conflicts at midnight — will thank you.

⭐ Star KiKit on GitHub | 💰 Sponsor Development | 📖 Read the Docs