klayout-draw-mcp 0.1.0__tar.gz

klayout_draw_mcp-0.1.0/.github/workflows/docs.yml

@@ -0,0 +1,63 @@
+name: docs
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - "docs/**"
+      - "examples/**"
+      - "scripts/render_examples.py"
+      - "mkdocs.yml"
+      - ".github/workflows/docs.yml"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: pages
+  cancel-in-progress: false
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    env:
+      QT_QPA_PLATFORM: offscreen
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      # System libraries the headless klayout.lay renderer needs on Linux.
+      - name: Install system dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends \
+            xvfb libgl1 libegl1 libxkbcommon0 libfontconfig1 libdbus-1-3
+
+      - name: Install Python dependencies
+        run: pip install klayout "mkdocs-material>=9.5"
+
+      - name: Render example screenshots
+        run: xvfb-run -a python scripts/render_examples.py
+
+      - name: Build site
+        run: mkdocs build --strict
+
+      - uses: actions/upload-pages-artifact@v3
+        with:
+          path: site
+
+  deploy:
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - id: deployment
+        uses: actions/deploy-pages@v4

klayout_draw_mcp-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,53 @@
+name: publish
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Build sdist and wheel
+        run: |
+          pip install build
+          python -m build
+
+      - name: Check metadata
+        run: |
+          pip install twine
+          twine check dist/*
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    # Only publish on a real GitHub release, not on manual dispatch.
+    if: github.event_name == 'release'
+    environment:
+      name: pypi
+      url: https://pypi.org/project/klayout-draw-mcp/
+    permissions:
+      id-token: write   # OIDC token for PyPI Trusted Publishing
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

klayout_draw_mcp-0.1.0/.gitignore

@@ -0,0 +1,20 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+build/
+dist/
+.venv/
+
+# Editor / OS
+.vscode/
+.idea/
+.DS_Store
+
+# Generated layouts
+*.gds
+*.oas
+*.gds.gz
+
+# MkDocs build output
+site/

klayout_draw_mcp-0.1.0/.python-version

@@ -0,0 +1 @@
+3.13

klayout_draw_mcp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 geniuskey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

klayout_draw_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: klayout-draw-mcp
+Version: 0.1.0
+Summary: MCP server for drawing, generating, and editing GDS layouts with KLayout.
+Project-URL: Homepage, https://github.com/geniuskey/klayout-draw-mcp
+Project-URL: Documentation, https://geniuskey.github.io/klayout-draw-mcp/
+Project-URL: Repository, https://github.com/geniuskey/klayout-draw-mcp
+Project-URL: Issues, https://github.com/geniuskey/klayout-draw-mcp/issues
+Author-email: geniuskey <geniuskey@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: drawing,eda,gds,klayout,layout,mcp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Electronic Design Automation (EDA)
+Requires-Python: >=3.10
+Requires-Dist: klayout>=0.29
+Requires-Dist: mcp>=1.2.0
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.5; extra == 'docs'
+Description-Content-Type: text/markdown
+
+# klayout-draw-mcp
+
+An [MCP](https://modelcontextprotocol.io) server for **drawing GDS layouts** with **KLayout** — generate, edit, and view layouts from an AI assistant such as Claude Code or Claude Desktop.
+
+Layout geometry is built in-process with the standalone [`klayout`](https://pypi.org/project/klayout/) Python module (no GUI needed). The installed KLayout application is launched only for viewing or manual editing.
+
+## Tools
+
+| Tool | Purpose |
+| --- | --- |
+| `new_layout(top_cell, dbu)` | Start a new in-memory layout (coordinates in micrometers) |
+| `add_box(layer, x1, y1, x2, y2, datatype)` | Add a rectangle |
+| `add_polygon(layer, points, datatype)` | Add a polygon from `[x, y]` vertices |
+| `add_path(layer, points, width, datatype)` | Add a path with width |
+| `add_label(layer, x, y, text, datatype)` | Add a text label |
+| `layout_info()` | Inspect current layout (layers, bbox, shape count) |
+| `save_gds(path, open_after)` | Write GDS/OASIS; optionally open in the editor |
+| `open_layout(file_path)` | Open a file in KLayout (viewer) |
+| `open_editor(file_path?)` | Open KLayout in editor mode, or a blank layout |
+| `run_script(code)` | Run arbitrary Python with `klayout.db` (cell hierarchy, arrays, booleans, DRC, ...) |
+
+## Requirements
+
+- Python ≥ 3.10
+- The `klayout` and `mcp` Python packages (installed via the steps below)
+- The [KLayout application](https://www.klayout.de/build.html) — only needed for `open_layout` / `open_editor`
+
+## Install
+
+```bash
+uv sync
+```
+
+## Register with Claude Code
+
+```bash
+claude mcp add klayout -s user -- "<repo>/.venv/Scripts/python.exe" -m klayout_draw_mcp.server
+```
+
+On macOS/Linux use `.venv/bin/python`.
+
+## Usage
+
+> "Draw a 5×5 µm box on layer 1 and a 2 µm-wide path, then save to out.gds and open it."
+
+Claude calls `new_layout` → `add_box` / `add_path` → `save_gds(open_after=True)`.
+
+For anything beyond the basic shapes, `run_script` exposes the full `klayout.db` API.
+
+## Examples
+
+Self-contained scripts in [`examples/`](examples). Each builds a layout with the
+standalone `klayout.db` module and writes a GDS:
+
+```bash
+uv run python examples/cis_aps_pixel.py out.gds
+```
+
+You can also paste the body of a script's `build()` function into the `run_script`
+tool. The scripts share one layer map (OD 3/0, POLY 6/0, NPLUS 4/0, METAL1 9/0, ...).
+
+| Example | What it draws |
+| --- | --- |
+| `basic_shapes.py` | The four primitives: box, path, polygon, label |
+| `nmos_transistor.py` | A single NMOS (active, poly gate, n+, contacts, M1 S/G/D) |
+| `cmos_inverter.py` | A CMOS inverter: PMOS over NMOS, shared gate, Vdd/Vss rails |
+| `cis_aps_pixel.py` | A 1 µm 4T CMOS image-sensor pixel, tiled as a 2×2 array |
+
+## Note
+
+`run_script` executes arbitrary Python locally, in-process. Only run scripts you trust.

klayout_draw_mcp-0.1.0/README.md

@@ -0,0 +1,71 @@
+# klayout-draw-mcp
+
+An [MCP](https://modelcontextprotocol.io) server for **drawing GDS layouts** with **KLayout** — generate, edit, and view layouts from an AI assistant such as Claude Code or Claude Desktop.
+
+Layout geometry is built in-process with the standalone [`klayout`](https://pypi.org/project/klayout/) Python module (no GUI needed). The installed KLayout application is launched only for viewing or manual editing.
+
+## Tools
+
+| Tool | Purpose |
+| --- | --- |
+| `new_layout(top_cell, dbu)` | Start a new in-memory layout (coordinates in micrometers) |
+| `add_box(layer, x1, y1, x2, y2, datatype)` | Add a rectangle |
+| `add_polygon(layer, points, datatype)` | Add a polygon from `[x, y]` vertices |
+| `add_path(layer, points, width, datatype)` | Add a path with width |
+| `add_label(layer, x, y, text, datatype)` | Add a text label |
+| `layout_info()` | Inspect current layout (layers, bbox, shape count) |
+| `save_gds(path, open_after)` | Write GDS/OASIS; optionally open in the editor |
+| `open_layout(file_path)` | Open a file in KLayout (viewer) |
+| `open_editor(file_path?)` | Open KLayout in editor mode, or a blank layout |
+| `run_script(code)` | Run arbitrary Python with `klayout.db` (cell hierarchy, arrays, booleans, DRC, ...) |
+
+## Requirements
+
+- Python ≥ 3.10
+- The `klayout` and `mcp` Python packages (installed via the steps below)
+- The [KLayout application](https://www.klayout.de/build.html) — only needed for `open_layout` / `open_editor`
+
+## Install
+
+```bash
+uv sync
+```
+
+## Register with Claude Code
+
+```bash
+claude mcp add klayout -s user -- "<repo>/.venv/Scripts/python.exe" -m klayout_draw_mcp.server
+```
+
+On macOS/Linux use `.venv/bin/python`.
+
+## Usage
+
+> "Draw a 5×5 µm box on layer 1 and a 2 µm-wide path, then save to out.gds and open it."
+
+Claude calls `new_layout` → `add_box` / `add_path` → `save_gds(open_after=True)`.
+
+For anything beyond the basic shapes, `run_script` exposes the full `klayout.db` API.
+
+## Examples
+
+Self-contained scripts in [`examples/`](examples). Each builds a layout with the
+standalone `klayout.db` module and writes a GDS:
+
+```bash
+uv run python examples/cis_aps_pixel.py out.gds
+```
+
+You can also paste the body of a script's `build()` function into the `run_script`
+tool. The scripts share one layer map (OD 3/0, POLY 6/0, NPLUS 4/0, METAL1 9/0, ...).
+
+| Example | What it draws |
+| --- | --- |
+| `basic_shapes.py` | The four primitives: box, path, polygon, label |
+| `nmos_transistor.py` | A single NMOS (active, poly gate, n+, contacts, M1 S/G/D) |
+| `cmos_inverter.py` | A CMOS inverter: PMOS over NMOS, shared gate, Vdd/Vss rails |
+| `cis_aps_pixel.py` | A 1 µm 4T CMOS image-sensor pixel, tiled as a 2×2 array |
+
+## Note
+
+`run_script` executes arbitrary Python locally, in-process. Only run scripts you trust.

klayout_draw_mcp-0.1.0/docs/examples.md

@@ -0,0 +1,64 @@
+# Examples
+
+Self-contained scripts live in [`examples/`](https://github.com/geniuskey/klayout-draw-mcp/tree/main/examples).
+Each one builds a layout with the standalone `klayout.db` module and writes a GDS:
+
+```bash
+uv run python examples/cis_aps_pixel.py out.gds
+```
+
+You can also paste the body of a script's `build()` function into the `run_script`
+tool. All examples share one layer map (OD `3/0`, POLY `6/0`, NPLUS `4/0`,
+PPLUS `5/0`, METAL1 `9/0`, NWELL `1/0`, PWELL `2/0`, CONT `8/0`, TEXT `63/0`, …).
+
+The screenshots below are rendered headlessly with `klayout.lay` by
+[`scripts/render_examples.py`](https://github.com/geniuskey/klayout-draw-mcp/blob/main/scripts/render_examples.py),
+the same way the documentation builds them in CI.
+
+## Basic shapes
+
+The four primitives — box, path, polygon and label — on a few layers. The place to
+start if you just want to see geometry come out.
+
+![Basic shapes layout](assets/images/basic_shapes.png){ loading=lazy }
+
+```python title="examples/basic_shapes.py"
+--8<-- "examples/basic_shapes.py"
+```
+
+## NMOS transistor
+
+A single planar n-channel MOSFET (W = 1 µm, L = 0.4 µm): active diffusion, a poly
+gate crossing the channel, n+ source/drain implant, and contacts plus metal-1 pads
+for source (S), gate (G) and drain (D).
+
+![NMOS transistor layout](assets/images/nmos_transistor.png){ loading=lazy }
+
+```python title="examples/nmos_transistor.py"
+--8<-- "examples/nmos_transistor.py"
+```
+
+## CMOS inverter
+
+A pull-up PMOS (in an n-well, top) over a pull-down NMOS (in the p-well, bottom),
+sharing one poly gate (the input, in red). The two drains are tied together on
+metal-1 (the output). Vdd rails the top, Vss the bottom, with well ties on each.
+
+![CMOS inverter layout](assets/images/cmos_inverter.png){ loading=lazy }
+
+```python title="examples/cmos_inverter.py"
+--8<-- "examples/cmos_inverter.py"
+```
+
+## CIS APS pixel
+
+A simplified 1 µm 4T CMOS image-sensor pixel: a large photodiode (PD), a transfer
+gate (TX) to the floating diffusion (FD), and reset (RST), source-follower (SF) and
+row-select (SEL) transistors in the shared active column. The unit pixel is drawn
+into its own cell and instanced as a 2×2 array, the way a real sensor array repeats.
+
+![CIS APS pixel 2x2 array](assets/images/cis_aps_pixel.png){ loading=lazy }
+
+```python title="examples/cis_aps_pixel.py"
+--8<-- "examples/cis_aps_pixel.py"
+```

klayout_draw_mcp-0.1.0/docs/index.md

@@ -0,0 +1,64 @@
+# klayout-draw-mcp
+
+[![PyPI](https://img.shields.io/pypi/v/klayout-draw-mcp.svg)](https://pypi.org/project/klayout-draw-mcp/)
+[![Python](https://img.shields.io/pypi/pyversions/klayout-draw-mcp.svg)](https://pypi.org/project/klayout-draw-mcp/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/geniuskey/klayout-draw-mcp/blob/main/LICENSE)
+
+An [MCP](https://modelcontextprotocol.io) server for **drawing GDS layouts** with
+**[KLayout](https://www.klayout.de)** — generate, edit and view chip layouts straight
+from an AI assistant such as Claude Code or Claude Desktop.
+
+Layout geometry is built in-process with the standalone
+[`klayout`](https://pypi.org/project/klayout/) Python module — no GUI needed. The
+installed KLayout application is launched only when you want to view or hand-edit a
+result.
+
+> "Draw a CIS 4T APS pixel at 1 µm pitch, tile it 2×2, then save to `out.gds` and open it."
+
+The assistant calls `new_layout` → drawing tools / `run_script` → `save_gds(open_after=True)`.
+See the [Examples](examples.md) for layouts produced exactly this way.
+
+## Tools
+
+| Tool | Purpose |
+| --- | --- |
+| `new_layout(top_cell, dbu)` | Start a new in-memory layout (coordinates in micrometers) |
+| `add_box(layer, x1, y1, x2, y2, datatype)` | Add a rectangle |
+| `add_polygon(layer, points, datatype)` | Add a polygon from `[x, y]` vertices |
+| `add_path(layer, points, width, datatype)` | Add a path with width |
+| `add_label(layer, x, y, text, datatype)` | Add a text label |
+| `layout_info()` | Inspect current layout (layers, bbox, shape count) |
+| `save_gds(path, open_after)` | Write GDS/OASIS; optionally open in the editor |
+| `open_layout(file_path)` | Open a file in KLayout (viewer) |
+| `open_editor(file_path?)` | Open KLayout in editor mode, or a blank layout |
+| `run_script(code)` | Run arbitrary Python with `klayout.db` (cell hierarchy, arrays, booleans, DRC, …) |
+
+## Install
+
+```bash
+pip install klayout-draw-mcp
+```
+
+The [KLayout application](https://www.klayout.de/build.html) is only required for
+`open_layout` / `open_editor`.
+
+## Register with Claude Code
+
+```bash
+claude mcp add klayout -s user -- python -m klayout_draw_mcp.server
+```
+
+When running from a checkout, point at the project's interpreter instead, e.g.
+`<repo>/.venv/Scripts/python.exe` on Windows or `<repo>/.venv/bin/python` on macOS/Linux.
+
+## How it works
+
+There are two complementary ways to produce geometry:
+
+1. **High-level drawing tools** (`new_layout`, `add_box`, `add_polygon`, …) build a
+   layout step by step. All coordinates are in micrometers.
+2. **`run_script`** executes arbitrary Python with `klayout.db` available, for anything
+   the high-level tools do not cover — cell hierarchy, array instances, boolean ops, DRC.
+
+!!! warning
+    `run_script` executes arbitrary Python locally, in-process. Only run scripts you trust.

klayout_draw_mcp-0.1.0/examples/basic_shapes.py

@@ -0,0 +1,67 @@
+"""Basic shapes sample for klayout-draw-mcp.
+
+Shows the four primitives (box, path, polygon, label) on a few layers.
+
+Run standalone:
+    uv run python examples/basic_shapes.py [out.gds]
+
+Or paste the body of ``build()`` into the ``run_script`` MCP tool (``db`` is
+injected there; ``ly``/``top`` map to ``session.layout``/``session.top``).
+"""
+
+from __future__ import annotations
+
+import klayout.db as db
+
+# Shared layer map used across the examples: name -> (layer, datatype)
+LAYERS = {
+    "OD": (3, 0),     # active / diffusion
+    "POLY": (6, 0),   # gate poly
+    "M1": (9, 0),     # metal 1
+    "TEXT": (63, 0),  # labels
+}
+
+
+def build() -> db.Layout:
+    ly = db.Layout()
+    ly.dbu = 0.001  # 1 nm grid
+    top = ly.create_cell("BASIC")
+
+    def lay(name: str) -> int:
+        return ly.layer(*LAYERS[name])
+
+    def box(name, x1, y1, x2, y2):
+        top.shapes(lay(name)).insert(db.DBox(x1, y1, x2, y2))
+
+    def path(name, pts, width):
+        top.shapes(lay(name)).insert(db.DPath([db.DPoint(*p) for p in pts], width))
+
+    def polygon(name, pts):
+        top.shapes(lay(name)).insert(db.DPolygon([db.DPoint(*p) for p in pts]))
+
+    def label(name, x, y, text):
+        top.shapes(lay(name)).insert(db.DText(text, db.DTrans(db.DVector(x, y))))
+
+    # a rectangle
+    box("OD", 0.0, 0.0, 5.0, 5.0)
+
+    # a 0.5 um wide L-shaped path
+    path("M1", [(0.0, 6.0), (5.0, 6.0), (5.0, 10.0)], 0.5)
+
+    # a triangle polygon
+    polygon("POLY", [(7.0, 0.0), (12.0, 0.0), (9.5, 5.0)])
+
+    # a couple of labels
+    label("TEXT", 2.5, 2.5, "box")
+    label("TEXT", 9.5, 1.5, "polygon")
+
+    return ly
+
+
+if __name__ == "__main__":
+    import sys
+
+    out = sys.argv[1] if len(sys.argv) > 1 else "basic_shapes.gds"
+    layout = build()
+    layout.write(out)
+    print(f"wrote {out}  bbox={layout.top_cell().dbbox().to_s()} um")

klayout_draw_mcp-0.1.0/examples/cis_aps_pixel.py

@@ -0,0 +1,128 @@
+"""CIS 4T active-pixel-sensor (APS) sample for klayout-draw-mcp.
+
+A simplified 1 um 4T CMOS image-sensor pixel: a large photodiode (PD), a
+transfer gate (TX) to the floating diffusion (FD), and reset (RST),
+source-follower (SF) and row-select (SEL) transistors in the shared active
+column. The unit pixel is drawn into its own cell and instanced as a 2x2
+array, the way a real sensor array repeats.
+
+Run standalone:
+    uv run python examples/cis_aps_pixel.py [out.gds]
+
+Or paste the body of ``build()`` into the ``run_script`` MCP tool.
+"""
+
+from __future__ import annotations
+
+import klayout.db as db
+
+# Shared layer map: name -> (layer, datatype)
+LAYERS = {
+    "PWELL": (2, 0),
+    "OD": (3, 0),     # active / diffusion
+    "NPLUS": (4, 0),  # n+ implant
+    "PPLUS": (5, 0),  # p+ well tap
+    "POLY": (6, 0),   # gate poly (TX / RST / SF / SEL)
+    "CONT": (8, 0),
+    "M1": (9, 0),
+    "PD": (10, 0),    # photodiode n-implant
+    "TEXT": (63, 0),
+    "BND": (100, 0),  # pixel boundary marker
+}
+
+PIXEL_PITCH = 1.0  # um
+ARRAY = (2, 2)     # columns, rows
+
+
+def build() -> db.Layout:
+    ly = db.Layout()
+    ly.dbu = 0.001
+    top = ly.create_cell("CIS_APS")
+    pix = ly.create_cell("APS_PIXEL")
+
+    def lay(name: str) -> int:
+        return ly.layer(*LAYERS[name])
+
+    def box(name, x1, y1, x2, y2):
+        pix.shapes(lay(name)).insert(db.DBox(x1, y1, x2, y2))
+
+    def label(name, x, y, text):
+        pix.shapes(lay(name)).insert(db.DText(text, db.DTrans(db.DVector(x, y))))
+
+    def cont(cx, cy):
+        box("CONT", cx - 0.02, cy - 0.02, cx + 0.02, cy + 0.02)
+
+    # pixel boundary + well
+    box("BND", 0.0, 0.0, 1.0, 1.0)
+    box("PWELL", 0.0, 0.0, 1.0, 1.0)
+
+    # photodiode (left, large fill factor)
+    box("PD", 0.05, 0.05, 0.55, 0.95)
+    box("OD", 0.08, 0.08, 0.52, 0.92)
+
+    # transfer gate TX, bridging PD -> FD
+    box("POLY", 0.50, 0.58, 0.60, 0.82)
+
+    # floating diffusion FD
+    box("OD", 0.58, 0.60, 0.70, 0.80)
+    box("NPLUS", 0.57, 0.59, 0.71, 0.81)
+
+    # shared transistor active column on the right
+    box("OD", 0.70, 0.06, 0.94, 0.94)
+    box("NPLUS", 0.69, 0.05, 0.95, 0.95)
+
+    # RST / SF / SEL gates (horizontal poly across the column)
+    box("POLY", 0.66, 0.66, 0.97, 0.74)   # RST
+    box("POLY", 0.66, 0.40, 0.97, 0.48)   # SF
+    box("POLY", 0.66, 0.16, 0.97, 0.24)   # SEL
+
+    # p-well tap (Vss), bottom-left
+    box("OD", 0.10, 0.10, 0.24, 0.20)
+    box("PPLUS", 0.09, 0.09, 0.25, 0.21)
+
+    # contacts
+    cont(0.64, 0.70)                      # FD
+    cont(0.18, 0.15)                      # Vss tap
+    for cy in (0.11, 0.32, 0.57, 0.84):   # right column source/drains
+        cont(0.82, cy)
+    cont(0.69, 0.70)                      # RST gate
+    cont(0.69, 0.44)                      # SF gate
+    cont(0.69, 0.20)                      # SEL gate
+
+    # metal-1: FD -> SF gate strap, and a Vdd rail
+    box("M1", 0.62, 0.68, 0.72, 0.72)
+    box("M1", 0.66, 0.44, 0.72, 0.72)
+    box("M1", 0.88, 0.06, 0.95, 0.94)
+
+    # labels
+    label("TEXT", 0.26, 0.48, "PD")
+    label("TEXT", 0.50, 0.86, "TX")
+    label("TEXT", 0.60, 0.83, "FD")
+    label("TEXT", 0.74, 0.69, "RST")
+    label("TEXT", 0.76, 0.43, "SF")
+    label("TEXT", 0.74, 0.19, "SEL")
+    label("TEXT", 0.10, 0.23, "Vss")
+    label("TEXT", 0.90, 0.965, "Vdd")
+
+    # tile the unit pixel into a 2x2 array
+    nx, ny = ARRAY
+    top.insert(
+        db.DCellInstArray(
+            pix.cell_index(),
+            db.DTrans(db.DVector(0.0, 0.0)),
+            db.DVector(PIXEL_PITCH, 0.0),
+            db.DVector(0.0, PIXEL_PITCH),
+            nx,
+            ny,
+        )
+    )
+    return ly
+
+
+if __name__ == "__main__":
+    import sys
+
+    out = sys.argv[1] if len(sys.argv) > 1 else "cis_aps.gds"
+    layout = build()
+    layout.write(out)
+    print(f"wrote {out}  bbox={layout.top_cell().dbbox().to_s()} um")