API Reference

Read a GDS file and return a Library.

lib = read_gds("input.gds")
for cell in lib.cells():
    print(cell.name)

Write a Cell or Library to a GDS file.

When writing a Cell built using Instance references (via cell.at()), child cells are automatically collected. A build summary is printed to stderr by default.

# Auto-collection (recommended):
top = Cell("top")
top.add_ref(gc_cell.at(0, 0))
write_gds("output.gds", top)

# Suppress output for batch processing:
write_gds("output.gds", top, quiet=True)

Load layer definitions from rosette.toml.

Reads the [layers] section which maps semantic names to GDS layer numbers with optional display properties (color, fill, opacity).

layers = load_layer_map()
layers.silicon.layer   # Layer(1, 0)
layers.silicon.color   # "#ff69b4"

Load DRC rules from rosette.toml.

Searches for rosette.toml in the current directory and parent directories. Rules are defined per-layer in the [drc.layers] section (supporting min_width, min_spacing, min_area, angles, min_edge_length, max_width, and no_self_intersection), and inter-layer rules in the [[drc.rules]] array.

rules = load_drc_rules()
result = run_drc(cell, rules)

Run DRC on a cell.

rules = load_drc_rules()
result = run_drc(cell, rules)
if result.passed:
    print("DRC passed!")
else:
    for v in result.violations:
        print(f"  {v.message}")

Load design checks config from rosette.toml.

Reads the [checks] section. If absent, returns a ChecksConfig with sensible defaults.

config = load_checks_config()
result = run_checks(cell, config)

Run design checks on a cell.

Runs all design checks: connectivity (unconnected ports, width/angle mismatch) and bend radius (below minimum, auto-reduced). Ports on the top-level cell are treated as external I/O and are not flagged as unconnected.

When called with a Cell built using Instance references, child cells are automatically collected into a Library for hierarchy resolution.

config = ChecksConfig(min_bend_radius=5.0)
result = run_checks(cell, config)
if not result.passed:
    for v in result.violations:
        print(f"  {v.message}")

Load DFM configuration from rosette.toml.

Reads the [dfm] section which configures the virtual nanofabrication prediction tool.

config, model, layers = load_dfm_config()
result = run_dfm(cell, layers=layers, model=model, config=config)

Run DFM prediction on a cell.

Rasterizes each specified layer, applies the fabrication prediction model, and extracts contour polygons representing the predicted fabricated geometry.

result = run_dfm(cell, layers=[Layer(1, 0)])
for lp in result.layers:
    print(f"  Layer {lp.layer}: {lp.input_polygon_count} -> {lp.predicted_polygon_count}")

Add DFM predicted polygons to a cell on offset layers.

For each layer in the DFM result, adds the predicted polygons to the cell on a new layer with the same number but datatype offset by datatype_offset. This makes it easy to visualize designed vs predicted geometry side-by-side.

result = run_dfm(cell, layers=[Layer(1, 0)])
add_dfm_predictions(cell, result)
write_gds("output.gds", cell)
# Layer 1/0 = designed, Layer 1/100 = predicted

Generate points along a circular arc.

Create a polygon from a centerline and uniform width.

The polygon is created by offsetting the centerline perpendicular to the path direction at each point, forming a "ribbon" shape.

Create a polygon from a centerline with varying width.

Similar to offset_polygon, but allows specifying a different width at each centerline point for tapered or variable-width shapes.

Calculate the total length of a polyline path.

Fresnel cosine integral C(t).

Used for generating Euler (clothoid) spiral bends. C(t) = integral from 0 to t of cos(pi/2 * u^2) du.

Fresnel sine integral S(t).

Used for generating Euler (clothoid) spiral bends. S(t) = integral from 0 to t of sin(pi/2 * u^2) du.