Chapter 30Design Flow and Open PDKs

From an idea to a GDS file: the design flow, the tools, and the open process design kits that let anyone tape out.

In this chapter you will learn to
  • describe the photonic design flow from concept to tape-out;
  • explain what a PDK contains: layers, cells, compact models and rules;
  • lay out with KLayout and SiEPIC-Tools, or as code with gdsfactory;
  • choose a component solver (mode solver, EME, FDTD) and simulate circuits with S-parameters;
  • verify a design and submit it to an openEBL run.
Design question

What happens between a simulation and a manufacturable layout?

30.1The design flow

A photonic design moves through the same stages as an electronic one, with different physics at each:

  1. Concept: the function, its specifications and a block diagram (for example the reference link of Chapter 1).
  2. Component simulation: the cross-sections and devices, with mode solvers and propagation solvers (Section 30.5).
  3. Compact models: each device reduced to a frequency-dependent scattering matrix, often fitted to simulation or measurement.
  4. Circuit simulation: the devices connected, and the circuit’s response computed from the compact models (Section 30.6).
  5. Layout: the geometry drawn on the foundry’s layers, from PDK cells and routed waveguides (Sections 30.3–30.4).
  6. Verification: design-rule checks, connectivity checks and design-for-test rules (Section 30.7).
  7. Tape-out: the GDS file sent to the foundry (Section 30.8), then testing (Chapter 31) and analysis (Chapter 32), whose results update the compact models.

30.2Process design kits

A process design kit (PDK) is the foundry’s description of its process, packaged for design tools:

  • the layer table: which GDS layer is the full etch, the partial etch, each implant, each metal;
  • cells and parameterised cells (PCells): grating couplers, edge couplers, Y-branches, MMIs, rings, modulators, photodiodes, pads, each validated on silicon;
  • compact models of those cells for circuit simulation;
  • design rules: minimum widths, gaps, enclosures and densities;
  • often a layer stack (thicknesses and materials) for simulation, and design-for-test rules.

Most commercial PDKs are under non-disclosure agreements. This tutorial uses only open ones: the SiEPIC EBeam PDK [15] and its gdsfactory version [18], the CORNERSTONE PDKs [19] and the Luxtelligence TFLN PDK [21]. Their devices, credited to their designers, are shown in the 3D gallery, extruded from their layouts with their published layer stacks.

30.3Layout with KLayout and SiEPIC-Tools

KLayout is an open-source layout viewer and editor [22]. The SiEPIC-Tools package adds what photonic layout needs [16]: placing PDK cells, routing waveguides between their ports with bends of the right radius, extracting a netlist from the layout (which device connects to which), running a circuit simulation from that netlist, and checking the design-for-test rules. Interactive layout suits small designs and is how most openEBL submissions are made.

30.4Layout as code with gdsfactory

gdsfactory builds layouts from Python (or YAML) code [17]. A component is a function of its parameters; a circuit is a composition of components and routes; a PDK is a Python package of components, layers and models. Writing layout as code makes parameter sweeps, variations and regression tests easy. A family of 20 rings with different gaps is a loop. It also connects directly to simulators: mode solvers, FDTD and circuit simulation from the same description. The 3D models in the gallery were generated with gdsfactory from the open PDKs.

30.5Component simulation

Three kinds of solver cover most needs, from fast to general:

  • Mode solvers (finite-difference or finite-element eigenmode, FDE/FEM) find the modes of a cross-section: effective and group indices, confinement, overlaps. This tutorial’s numbers come from the open finite-element solver femwell: the strip modes of Chapter 6, the supermodes of Chapters 9 and 27, the inverse tapers of Chapter 16, the PN junction of Chapter 19.
  • Eigenmode expansion (EME) propagates light through a device that changes along its length by expanding the field in local modes at each section. It is fast for tapers, MMIs and couplers.
  • Finite-difference time-domain (FDTD) solves Maxwell’s equations directly on a grid in time, for any geometry, including gratings and reflections. It is the most general and the most expensive; MEEP is the open-source standard [24]. Two-dimensional FDTD with an effective index (Chapter 6) is a quick first pass for grating couplers.

30.6Circuit simulation

A circuit of tens or thousands of devices is too large for any field solver. Instead, each device becomes a compact model, its scattering matrix as a function of wavelength. For a directional coupler this is a 4 × 4 matrix whose cross terms carry the \(-j\kappa\) of Chapter 9; for a waveguide, a phase \(e^{-j\beta L}\) with \(\beta(\lambda)\) from its effective and group indices. A circuit simulator connects the matrices according to the netlist and solves for the response at the circuit’s ports. SAX does this in Python, with automatic differentiation for optimisation [23]; KLayout/SiEPIC-Tools links to circuit simulators from the extracted netlist.

Try it. Build an MZI or a lattice filter from couplers and delays, see the netlist, and change the coupling ratios.

// try it · circuit simulation from compact models: couplers and delays in a chain
geometry: netlist layout, delays not to scale
transmission to the two outputs
netlist (instances, models and connections)
FSR –bar port at 1550 nm –cross port at 1550 nm –flat-top width (−1 dB) –

30.7Verification

Before tape-out, a design is checked:

  • Design-rule checks (DRC): every shape obeys the foundry’s minimum widths, gaps and enclosures; KLayout runs the PDK’s rule deck.
  • Connectivity: every waveguide port connects to something, with matched widths; no waveguide crosses another unintentionally; the extracted netlist matches the intended circuit.
  • Design for test: grating couplers on the fibre-array pitch, all facing the same way, with test labels (Chapter 17).
  • Simulation of the layout itself: the circuit simulated from the netlist extracted from the drawn layout, not from the schematic, which catches routing lengths and bends that change phases.

30.8Tape-out through openEBL

The openEBL runs accept designs through GitHub: a designer adds a GDS file to the run’s repository by pull request, automated checks run DRC and the design-for-test rules on it, and the merged designs are combined and fabricated. The chips are measured on an automated probe station and the data come back through the same repository [14]. The open designs and data of past runs are a rich source for learning, and for Chapter 32.

Your first chip

Draw the chip in KLayout with SiEPIC-Tools (or generate it with gdsfactory and ubcpdk): a loopback, cutback spirals, MZIs with two arm-length differences, rings with three gaps, and a Bragg grating, all on the 127 µm coupler column with test labels. Simulate the circuits from the extracted netlist, run DRC and the design-for-test check, and submit by pull request.

Reading

  • [17] Joaquin Matres et al. gdsfactory: a Python library for designing chips (photonics, analog, quantum, MEMS) (MIT licence). https://github.com/gdsfactory/gdsfactory
  • [16] Lukas Chrostowski and contributors. SiEPIC-Tools: integrated optics functionality for KLayout (MIT licence). https://github.com/SiEPIC/SiEPIC-Tools
  • [15] Lukas Chrostowski and contributors. SiEPIC EBeam PDK & Library, for SiEPIC-Tools and KLayout (MIT licence). https://github.com/SiEPIC/SiEPIC_EBeam_PDK
  • [18] gdsfactory contributors. ubcpdk: the SiEPIC EBeam PDK for gdsfactory (MIT licence). https://github.com/gdsfactory/ubc
  • [19] gdsfactory contributors. cspdk: the CORNERSTONE photonics PDK for gdsfactory (MIT licence). https://github.com/gdsfactory/cspdk
  • [21] Luxtelligence and gdsfactory contributors. lxt_pdk_gf: gdsfactory implementation of the Luxtelligence thin-film lithium niobate PDK (MIT licence). https://github.com/gdsfactory/lxt_pdk_gf
  • [23] Floris Laporte et al. SAX: S-parameter based frequency-domain circuit simulations and optimisation with JAX (Apache-2.0). https://github.com/flaport/sax
  • [24] Ardavan F. Oskooi, David Roundy, Mihai Ibanescu, Peter Bermel, J. D. Joannopoulos and Steven G. Johnson. “MEEP: a flexible free-software package for electromagnetic simulations by the FDTD method.” Computer Physics Communications, 181(3):687–702, 2010.
  • [22] Matthias Köfferlein. KLayout: a high-performance layout viewer and editor. https://www.klayout.de
  • [14] Mustafa Hammood, Sudip Shekhar and Lukas Chrostowski. “SiEPIC openEBL: remote silicon photonic design-fabrication-testing enabled by open-source process design kits and design tools.” 2025 IEEE Conference on Education and Training in Optics and Photonics (ETOP), Glasgow, 2025. doi:10.1109/ETOP64842.2025.11030682
Key takeaways
  • Flow: concept → component simulation → compact models → circuit simulation → layout → verification → tape-out → test → back to the models.
  • A PDK holds the layers, validated cells, compact models, rules and layer stack; open PDKs (SiEPIC EBeam, CORNERSTONE, Luxtelligence) make public designs possible.
  • KLayout with SiEPIC-Tools for interactive layout; gdsfactory for layout as code.
  • Mode solvers, EME and FDTD trade speed for generality; circuits are simulated from S-matrix compact models (SAX).
  • Verify with DRC, connectivity, design-for-test and layout-extracted simulation; openEBL takes designs and returns data through GitHub.