Step-by-step: drawing a neural electrode harness

Prerequisites

• Install klink: pip install klayout-klink (one command installs klink plus its Rust kernels -- no third-party scientific libraries needed).
• KLayout running with the klink plugin loaded (RPC port defaults to 8765).
• Scaffold a project and enter it: klink init nano-demo && cd nano-demo -- the full script is python example_template/nanodevice/neural_electrode.py --port <session-port> --elec-rows 4. In a repo checkout the equivalent is python -m examples_klink.public.demos.nanodevice.neural_electrode --port <session-port> --elec-rows 4.

1Create the cell + plan the layers

Every layer this device uses is example-owned (hardcoded layer numbers in example_template/nanodevice/neural_electrode.py) -- klink itself ships no process layers. Create the cell, set the Port/Anchor marker layers once, then ensure the 7 process layers plus klink's 3 reserved marker layers:

from klink import KLinkClient

with KLinkClient(port=PORT).connect() as c:
    c.cell_create(cell_name)
    c.call("port.set_layer", {"layer": "999/99"})
    c.call("anchor.set_layer", {"layer": "999/1"})
    for layer, name in ((1,"M1"),(2,"VIA13"),(3,"M3"),(4,"VIA35"),(5,"Pads"),(6,"Frame"),(7,"Protect")):
        c.layer_ensure(layer, 0, name=name)
    c.layer_ensure(999, 99, name="KLINK_PORTS")
    c.layer_ensure(999, 98, name="KLINK_ROUTE_PORTS")
    c.layer_ensure(999, 1, name="KLINK_ANCHORS")
    c.show_cell(cell_name, zoom_fit=False)

2Draw the probe body / shell

The probe body is a hollow "C"-shaped shell: on the left, a bond-pad housing (three walls, open on the right), narrowing into a rounded-transition neck, then forking into two thin upper/lower arms, and finally converging into a triangular tip far to the right -- exactly the "wide base + thin shank" shape of a real neural probe. _frame_items() draws one copy on layer 6/0 (Frame) and one on 7/0 (Protect) -- 7/0 gets two extra center/tip fill pieces -- 22 shapes total, written with one shape_insert_many call:

frame_items = _frame_items(spec)   # 22 box/polygon items, covering layers 6/0 + 7/0
c.shape_insert_many(cell_name, frame_items)

3Draw the bond pads + relay vias

Inside the housing, 24 nets are laid out along y; each net gets a 150x150 um bond pad (a typical probe-station/wire-bond pad size) at each of three x positions -- probe_pad_x_um=(-6650,-5450,-4250) -- for 3 columns x 24 rows = 72 pad squares total, relayed like a baton from the outermost position all the way to route_via_x_um=-3050. Half the nets (net_num <= pads_per_half) also get an extra pair of relay vias there -- the landing spot Stage 6's routing will use. This is the biggest single write in the whole tutorial: 288 shapes across 5 layers (1/0/2/0/3/0/4/0/5/0) in one RPC:

probe_items = items[frame_count:frame_count + probe_count]   # 288 shapes
c.shape_insert_many(cell_name, probe_items)

4Draw the electrode array (parametrized by --elec-rows)

At the far end of the shank sits the actual tissue-contacting electrode array: elec_rows rows x 3 columns, in two groups (elec_left_x_um near the neck, elec_right_x_um near the tip), each electrode pad only 20x21 um -- roughly an 8x size gap from the 150 um bond pads, the exact same "array pitch vs. probe-pad pitch, different scales" issue from this repo's CLAUDE.md, except both ends now live on one chip. Changing --elec-rows touches one number, and the row count, pad total, and shape count all move together:

The --elec-rows 2/6 rows are derived from the same HarnessPCellSpec formulas (pads_per_half/net_count are @propertys; the electrode shape count is elec_rows x 21) -- this tutorial actually ran --elec-rows 4, the other two rows were not independently re-run or screenshotted.

electrode_items = items[frame_count + probe_count:]   # elec_rows x 21 = 84 shapes (rows=4 here)
c.shape_insert_many(cell_name, electrode_items)

5Mark Port + corridor Anchor

With geometry drawn, intent-marking begins. There are three kinds of Port here: 24 bond-pad Ports (electrical, access_mode="edge", free to slide along the pad edge, one per net), 24 relay Ports (for routing, on auxiliary layer 999/98, also one per net), and 12+24 Ports on the electrode side -- one primary Port per (row, col) electrode site (on the elec_left side, its net field carries both the bottom_net and top_net tokens) plus two auxiliary Ports (ET{top_net} on the elec_left side, EB{bottom_net} on the elec_right side, each carrying just one net) -- 84 separate port.mark calls in total. Port creation goes through PCell instantiation, which is outside shape.insert_many's batch surface -- these really are 84 individual RPCs, and this tutorial shows that plainly instead of glossing over it.

There are only 2 Anchors, but a different kind from either earlier tutorial: kind="corridor", a mandatory lane running the full chip height, its width computed by corridor_width_um() (700 um here) -- every bond-pad-side trace must converge into this corridor before it can cross the neck. This reuses the same kind="corridor" concept from the EBL tutorial's "allowed crossing window," but for a completely different purpose: not obstacle avoidance, but forced convergence.

c.call("port.mark", {
    "cell": cell_name, "layer": "999/99", "name": "P36", "label": "n1",
    "center_um": [x, y], "orientation": 0, "width_um": 30.0,
    "port_type": "electrical", "net": "n1", "target_layer": "1/0",
    "access_mode": "edge", "slide_allowed": True, "slide_edge": "x0,y0,x1,y1",
})
c.call("anchor.mark", {
    "cell": cell_name, "layer": "999/1", "id": "A1_BOTTOM_M1_CORRIDOR",
    "kind": "corridor", "center_um": [-1650.0, 0.0], "width_um": 700.0,
    "path_points": "0,-1;0,1", "net": "n1,n2,...,n12", "priority": 1, "required": True,
})

6Corridor-constrained batch routing

Once everything is marked, one pass routes all 24 nets: pull every auxiliary Port and the corridor Anchors back in bulk with port.list/anchor.list, group by route_layer (1/0 in one group, 3/0 in the other), and call route_tapered_hybrid_many once per group (a visibility graph + Dijkstra plan, computed client-side in Python, no rasterization) followed by commit_tapered_hybrid_many (one batched RPC write-back):

from klink.routing.backends.geometric.tapered_segments import (
    pair_ports_by_net_tokens, route_tapered_hybrid_many, commit_tapered_hybrid_many,
)

ports = c.call("port.list", {"cell": cell_name, "layer": "999/98"})["ports"]
ports = [p for p in ports if str(p.get("name") or "").startswith(("R", "EB", "ET"))]
anchors = c.call("anchor.list", {"cell": cell_name, "layer": "999/1"})["anchors"]
pairs = pair_ports_by_net_tokens(ports)   # pair source/target by shared net token

by_layer = {}
for pair in pairs:
    by_layer.setdefault(pair.get("route_layer") or "10/0", []).append(pair)

for route_layer, layer_pairs in sorted(by_layer.items()):
    planned = route_tapered_hybrid_many(
        layer_pairs, anchors=anchors, spacing_um=8.0,
        strategy="uniform", angle_mode="manhattan", validate_sibling_overlap=True,
    )
    commit_tapered_hybrid_many(c, cell_name, planned, route_layer=route_layer, clear=True)

7Finish: overview + electrode-end detail

Routing was the last geometry write; Stage 7 just looks at the result:

c.zoom_fit()
overview = c.screenshot(mode="base64", width_px=1200)
detail = c.screenshot(mode="base64", bbox_um=[2370.0, -70.0, 2510.0, 70.0],
                       width_px=1200, height_px=1200)

Verify, don't just look

As the tutorials home page says: screenshots are for people, not proof of done. Here's the actual structured result from this run (--elec-rows 4):

{
  "shape_item_counts": {"frame": 22, "bondpads_and_vias": 288, "electrodes": 84, "total": 394},
  "port_count_total": 84,
  "anchor_count_total": 2,
  "route_result": {
    "ok": true,
    "port_count": 48,
    "anchor_count": 2,
    "pair_count": 24,
    "groups": [
      {"route_layer": "1/0", "route_count": 12, "sibling_overlap_count": 0, "obstacle_hit_count": 0, "inserted": 84},
      {"route_layer": "3/0", "route_count": 12, "sibling_overlap_count": 0, "obstacle_hit_count": 0, "inserted": 84}
    ]
  }
}

ok=true, and both route-layer groups report zero sibling_overlap_count/obstacle_hit_count -- meaning all 24 traces (12 on 1/0, 12 on 3/0) avoid each other with no crossed wiring; pair_count=24 equals net_count, meaning every net paired successfully with no orphaned Port. Together these three numbers -- not "it looks connected" -- are what "this parametric harness is correctly routed" actually rests on.

Next steps

Change --elec-rows to your own row count (say 2 or 6), check the shape counts against the formula table in Stage 4, and confirm route_result.ok is still true. If you haven't read the first two yet, read them in order: "Step-by-step: drawing a Hall bar device" (the geometry-first basics: mark Port/Anchor intent, then route) and "Step-by-step: drawing an EBL wraparound nanodevice" (writefield obstacle avoidance, where kind="corridor" windows first appear) -- this tutorial's corridor Anchor borrows that exact same kind for a completely different "forced convergence" purpose. Next up is a photonics-flavored gf_mzi_module tutorial (python -m examples_klink.public.demos.photonics.gf_mzi_module --port <session-port>), which switches to the gdsfactory bridge and an MZI device. The full Port/Anchor field reference is in the MCP reference; the full design boundary for batch RPCs is in this repo's CLAUDE.md, under "Use batch RPCs for generated layouts."