Skip to the content
2 layers52 × 36 mmLt3758 iso flyback manual, the printed circuit board in 3D

Lt3758 iso flyback manual

freudenthal/skidl-eda

skidl-eda: AI circuit-design loop harness on the skidl stack

Size
52 × 36 mm
Copper layers
2
Thickness
1.6 mm
Parts
36
Nets
23
Pads
97
Tracks, vias
0, 0
Routed
Not yet
KiCad
KiCad 10.0 (file 20260206)
Created
9 Jul 2026
Updated
6 Oct 2026

Overview

Lt3758 iso flyback manual is an open-source printed circuit board by freudenthal, from the freudenthal/skidl-eda repository on GitHub. It is a 2-layer board of 52 × 36 mm with 36 parts on 23 nets.

It is built around the PS2801-1, TL431 and BAS516, with the ES1D, FDC2512 and PA1277NL among its other parts. Its parts include 3 ICs and 2 connectors.

Main components

6

README

README.md

skidl-eda

An AI circuit-design loop harness built on the skidl stack. It turns a skidl circuit description into a KiCad-openable project and wraps it with the pieces an automated (or assisted) design loop needs: verification gates, part sourcing, SPICE simulation entry, an aggregate quality metric, a diagnostics knowledge base, human-in-the-loop regeneration from an edited schematic, and a scored PCB placement step.

What it does

  • Project generation — render a built skidl Circuit to a KiCad-10 project (.kicad_pro + .kicad_sch + .net) and run it through a gate pipeline.
  • Gates — structural netlist equivalence, ERC (with a net-aware PWR_FLAG autofix that reverts on regression), a KiCad save-crash gate, and a footprint check.
  • Exports — BOM (CSV) and schematic PDF via kicad-cli.
  • Sourcing — keyless JLCPCB search, a DigiKey/JLC availability facade, and a standalone symbol finder.
  • Simulation — a thin entry over skidl.sim to turn acceptance criteria into PASS/FAIL.
  • Evaluation — a weighted 0–100 design-quality grade (power connectivity, floating pins, decoupling coverage, net naming) plus a golden-netlist regression oracle.
  • Diagnostics — a failure-pattern knowledge base mapping symptoms to probable cause, solutions, and a test tree.
  • HITL regeneration — regenerate runnable skidl source from a schematic a human edited in KiCad, verified by a round-trip equivalence check.
  • PCB step — plan a board placement and emit a scored .kicad_pcb.

Architecture

skidl-eda is a peer package that composes several libraries:

PackageRole
skidlauthoring DSL + KiCad-10 backend + schematic router + skidl.sim
skidl-codegenKiCad schematic → runnable skidl source (HITL regeneration)
skidl-layoutPCB placement engine + layout-quality metrics
kicad-sch-apibyte-perfect KiCad round-trip / edit interface for the human-in-the-loop step

The core (generation + gates + evaluation + diagnostics + sourcing) depends only on skidl and kicad-cli. The HITL and PCB steps pull in skidl-codegen and skidl-layout respectively, and degrade gracefully (a clear "unavailable" result) when those optional peers are not installed.

Installation

skidl-eda and its peers are installed from local checkouts (editable during development). Python 3.13 or 3.14 is supported (verified end-to-end on CPython 3.13.14 + KiCad 10.0.4).

The commands below are run from inside this skidl-eda/ directory; the ../ peer paths assume the sibling checkouts sit directly beside it (the standard flat layout: skidl/, skidl-codegen/, skidl-layout/, kicad-sch-api/, and skidl-eda/ all under one parent).

bash
# create an environment (uv shown; venv/pip works the same)
uv venv --python 3.13 .venv

# install the peer packages editable, then skidl-eda
uv pip install -e ../skidl -e ../skidl-layout -e ../skidl-codegen -e ../kicad-sch-api
uv pip install -e .

# to run the tests AND any simulation, add both extras (neither pytest nor
# PySpice is in the base install):
uv pip install -e ".[test,sim]"

Other optional extras:

bash
uv pip install -e ".[sim]"       # PySpice for live skidl.sim simulation
uv pip install -e ".[sourcing]"  # requests, for keyed DigiKey sourcing
uv pip install -e ".[test]"      # pytest

Verify the install resolves to the local checkouts:

bash
python -c "import skidl, skidl_eda, kicad_sch_api, os; \
  print(os.path.dirname(skidl.__file__)); print(os.path.dirname(skidl_eda.__file__))"

A working KiCad 10 install (for its symbol/footprint libraries and kicad-cli) is required for the gate, export, and PCB steps. On this project it lives at C:\Program Files\KiCad\10.0\.

SPICE corpus auto-detection (heads-up)

setup_kicad10() auto-defaults SKIDL_SPICE_LIB_PATH to a KiCad-Spice-Library corpus found beside the checkouts, in ~/.skidl/, or above the cwd (so value="<vendor NAME>" auto-resolves out of the box — see below). A part authored as a generic device with a Sim_Params override (e.g. a diode value="1N4742A", Sim_Params="BV=12") whose value merely shares a name with a corpus .subckt still simulates as the intended generic model — the converter only binds a corpus subckt when Sim_Pins explicitly maps its nodes, or Sim_Prefer="library" is set. To pin a session to a specific corpus (or none), set SKIDL_SPICE_LIB_PATH yourself before setup_kicad10(); an already-set value always wins.

Usage

Point skidl at the KiCad-10 libraries

Always call setup_kicad10() before building a circuit. It binds skidl to the real KiCad-10 symbol directory (see the library note below for why this matters).

python
from skidl_eda import setup_kicad10
setup_kicad10()

Generate a KiCad project

python
from skidl_eda import setup_kicad10, generate, summarize

setup_kicad10()
from my_design import build            # your skidl circuit factory
result = generate(build(), "MyBoard", output_dir="build")
print(summarize(result))
# project: build/MyBoard -> OK
#   netlist PASS | schematic PASS | project PASS | footprint PASS
#   erc WARN (... ) | save_gate PASS | bom PASS | pdf PASS | evaluation PASS (grade 82/100)

generate() returns a result dict. ok reflects generation plus the save-crash gate (the "opens in KiCad" contract). ERC is report-only by default (result["erc_clean"], per-step autofixes_applied); pass erc_must_be_clean=True to make remaining ERC errors fail the run. The ERC PWR_FLAG autofix runs by default (erc_autofix=True) and needs kicad-sch-api.

Evaluate design quality

python
from skidl_eda import evaluation as E

report = E.evaluate_circuit(build())                          # structural grade
report = E.evaluate_circuit(build(), reference="golden.net")  # + regression oracle
print(E.summarize(report))

Diagnose a symptom

python
from skidl_eda import diagnostics as D

print(D.diagnose(["3.3V rail low", "regulator hot"]).summary())
# [80%] Overloaded voltage regulator -> Replace regulator ... + test tree

D.diagnose_design(evaluation=..., erc=...) feeds a design's own gate output in as symptoms.

Regenerate skidl source from an edited schematic (HITL)

After a human edits the project in KiCad (or via kicad-sch-api), regenerate the authoring source and verify it still describes the same circuit:

python
from skidl_eda import regenerate

res = regenerate("build/MyBoard/MyBoard.kicad_sch", output_dir="regen")
print(res.summary())          # "regenerated flat: EQUIV"
assert res.equivalent          # round-trip pin-partition equivalence passed

Plan a scored PCB

python
from skidl_eda import setup_kicad10, plan_pcb

setup_kicad10()
res = plan_pcb(build(), "build/MyBoard/MyBoard.kicad_pcb")
print(res["score"], res["overlaps"], res["pcb_written"])

The PCB step is also available inline as generate(..., pcb=True) (opt-in, report-only).

Fast in-loop layout. Both plan_pcb(...) and generate(..., pcb=True, pcb_options={...}) forward layout knobs to skidl_layout.plan_layout. For quick iteration, prune the 8-candidate portfolio:

python
# via generate(): pcb_options is forwarded verbatim to plan_pcb -> plan_layout
generate(build(), "MyBoard", pcb=True,
         pcb_options={"candidate_names": ["baseline", "connector_edge_first"]})

# or directly on plan_pcb() as **plan_kwargs
plan_pcb(build(), "build/MyBoard.kicad_pcb", max_candidates=2)

The SKIDL_LAYOUT_CANDIDATES / SKIDL_LAYOUT_MAX_CANDIDATES environment variables do the same with no code change (read inside plan_layout).

Find parts and check availability

bash
python -m skidl_eda.sourcing.find_symbol ADA4817      # search KiCad symbol libs
python
from skidl_eda.sourcing import check_availability
check_availability("C514314")   # keyless JLCPCB lookup

Use vendor SPICE models (KiCad-Spice-Library)

For simulation, skidl-eda can pull real vendor models from the KiCad-Spice-Library corpus (~50k .model/.subckt definitions). The corpus is referenced, never bundled — obtain it once (it carries heterogeneous vendor licenses):

bash
git clone --depth 1 https://github.com/kicad-spice-library/KiCad-Spice-Library \
  ~/.skidl/KiCad-Spice-Library
# or: python -m skidl_eda.sourcing.find_spice_model --help   (prints the command)
# or: python -c "from skidl_eda.sourcing import spice_library as s; s.ensure_library(install=True)"

It's auto-detected at ~/.skidl/KiCad-Spice-Library, beside this repo, or via SKIDL_SPICE_LIB_PATH (pointed at the corpus Models dir). Search for a model and get a paste-ready block:

bash
python -m skidl_eda.sourcing.find_spice_model TL072 --type opamp --verify
# TL072  (subckt)  Manufacturer/Texas Instruments/tl072.mod   license: vendor_restricted
#   value="TL072"   Sim_Compat="psa"
#   Sim_Pins="<pin_+in>=1 <pin_-in>=2 <pin_V+>=3 <pin_V->=4 <pin_out>=5"
#   # subckt nodes (assumed op-amp order): 1=+in, 2=-in, 3=V+, 4=V-, 5=out
#   verify: LOADS + converges

Two ways to attach a hit:

  • Auto-resolve — set SKIDL_SPICE_LIB_PATH to the corpus Models dir, then just name the part in value. Bare .model parts (most diodes/BJTs/MOSFETs) need no pin mapping; a .subckt (op-amps/ICs) also needs Sim_Pins or Sim_Prefer="library". A curated built-in datasheet_fit card always wins unless you set Sim_Prefer="library". Provenance is recorded as vendor_lib / source library_index in sim.model_provenance[ref].
  • Explicit — paste Sim_Library="<abs path>" + Sim_Name="<NAME>" (+ Sim_Pins), no env var needed.

Always keep Sim_Compat="psa" for corpus models. Corpus models are real but unvetted — prefer a built-in datasheet_fit when one exists. Vendor- restricted files are fine for local simulation; only permissive files are auto-copied into the shared model store (find_spice_model --into-store MPN; override with --allow-restricted). Optional gated check: generate(..., verify_models=True) smoke-tests every corpus-resolved part.

Requires KiCad's bundled ngspice (auto-configured on Windows); the codemodels needed for vendor POLY(n) macromodels are loaded automatically.

Auto-resolved models load a minimal deck, not the whole file. One malformed line anywhere in a vendor library makes ngspice reject every model defined in it — measured across this corpus: 2,101 load failures from just 102 files, 70 of them 100% dead (Zener_DiodesInc.lib alone defines 842 zeners). So the converter extracts only the models a netlist needs, plus their same-file dependencies (skidl.sim.model_deck); 1N4733A and its file-mates simulate because of it. Explicit Sim_Library= keeps its whole-file include — pinning a file is user intent, and the escape hatch by construction. SKIDL_SIM_MINIMAL_DECK=0 reverts everything to whole-file includes, and moves smoke_test/--verify with it so verification keeps predicting the sim path.

Sweep the corpus for reliability (corpus_eval)

The corpus is permanently unreliable — models fail to load, are the wrong dialect, have swapped terminal identity, have behavioral thresholds above your stimulus, or are numerically stiff. corpus_eval mechanizes the discovery: it wires each part into a canonical, per-class test circuit, runs it in a bounded subprocess (a hung ngspice can't stall the sweep), and writes tiered, hedged JSONL records + a markdown rollup.

bash
# the plain CLI (scriptable / for CI-style runs):
python -m skidl_eda.sourcing.corpus_eval --type diode --limit 20

# the WATCHABLE runner (start it and watch it go — live per-part lines, a
# running tally, rate/ETA, checkpoints; Ctrl-C-safe, resume with --resume):
python scripts/run_corpus_eval.py --type all --per-class-limit 250 --workers 8
python scripts/run_corpus_eval.py --type diode --limit 20        # a quick look

The sweep is an external batch operation — nothing in the package or its test suite ever triggers a real run; corpus_eval is opt-in and the reader only reads the JSONL if it exists. scripts/run_corpus_eval.py is the standalone runner you start by hand.

The score is tiered, never a single grade (a part can pass every single-instance test and still collapse in a multi-instance loop — see LMC6482):

  • dialect — can ngspice-in-KiCad run this class at all (yes/no/unknown); a hard no short-circuits (no sim).
  • loads / op_converges — the model parses and its .op converges.
  • functional — per-class metrics scored vs a formula: op-amp (follower / inverting G=−10 / open-loop rail / AC→GBW), diode (Vf@1mA, leakage, Vz), BJT (β, Vbe), MOSFET/FET (Vth/gm/Rds_on — with name-match → IR 10/20/30 → permutation-trial terminal identity), LDO (line/load/dropout; >3-terminal parts honestly untestable-generic), twoterm and threeterm (below). Status is pass / partial / fail / untestable-generic / untested.
  • transient_loop — always "untested" (Phase 2, not built): the standing hedge in every record and the report header.

twoterm / threeterm cover the ~19k 2- and 3-node subckts that used to fall through to the formula-less generic subckt class:

  • twoterm (2 nodes) — an AC driving-point impedance sweep (a 1 A AC source makes V(a) numerically equal to Z(f)) plus a DC I–V sweep classify the part into z_kind = inductive / capacitive / resistive / resonant / rectifying / clamping / zener / open, and measure l_h / c_f / r_ohm / srf_hz / vf_v / vz_v / vclamp_*. When the part name encodes its nominal (4532_7447669168_68u → 68 µH) that becomes a real pass/fail target at ±30 % — the same idea as LM7805 → 5 V. Kind is decided by a phase plurality over the midband, not a majority: a real 68 µH inductor reads resistive below its DCR corner and capacitive above its SRF, so it is inductive over barely half the sweep.
  • threeterm (3 nodes, not already claimed by mosfet/ldo) — a bounded 15-bench cascade: a 6-permutation FET trial → a 6-permutation regulator trial → 3 pairwise impedance probes. z_kind=transistor means a 3-terminal controlled conductor (FET/BJT/triode/SCR-like), not an identified device family. A passive network is partial, never pass — a pairwise impedance measurement does not verify what the part is for.

Not built on purpose: ≥4-node behavioral parts get no profile. Generic stimulus on an IR2104-class part yields confident false verdicts, so they stay honestly untested / untestable-generic.

Output (in .claude/memory/ by default): corpus_eval_results.jsonl (the exhaustive machine-readable store) + corpus_eval_report.md (a summarized, hedged rollup that documents any per-class sampling cap — no silent caps). The corpus holds ~44k models, so a full sweep needs --workers and is a multi-hour job; --per-class-limit runs a bounded representative sample (even-strided across the name space).

The measured records feed straight into find_spice_model's reliability: line through the single reader skidl_eda.sourcing.reliability — which merges the curated seed (diagnostics/data/spice_model_reliability.jsonl), the packaged measured snapshot (diagnostics/data/corpus_eval_results.jsonl.gz), a .claude/memory curated overlay, and any local measured results (a curated note always wins; a measured-only part gets a synthesized, hedged line).

Shipping a sweep (import_corpus_results)

A full sweep is a multi-hour job, so its result is bundled with the package rather than re-measured per checkout — a fresh clone inherits the measurements immediately, and a local sweep still overrides them on the machine that ran it.

bash
python scripts/import_corpus_results.py --dry-run   # preview + summary
python scripts/import_corpus_results.py             # bundle it

This reads <memory_dir>/corpus_eval_results.jsonl (snapshotting first, so it is safe to run while a sweep is going) and writes the gzipped package-data dataset. Gzip buys ~43× — a full corpus lands around half a megabyte. The output is byte-deterministic, so re-importing an unchanged store produces an empty diff.

Record validity: two hashes

Every record carries two hashes that make staleness detectable, so a re-run refreshes only what actually needs it:

  • file_hash — fast blake2b of the model file's bytes. Proves the record still describes the data on disk; if the corpus file changes, the entry is stale.
  • harness_hash — hash of HARNESS_VERSION plus the source of the shared and per-class bench builders/scorers. Editing one class's profile invalidates only that class; editing shared logic invalidates everything.

--resume skips a part only when both hashes match, so blanking harness_hash marks an entry for re-run:

bash
python scripts/update_corpus_hashes.py            # dry run: what would re-run
python scripts/update_corpus_hashes.py --apply --backup

That backfills both hashes into an existing store and invalidates the records that failed to load or errored (~4 s for 20k records). Then re-run the sweep with --resume to refresh exactly those.

Whole-file poisoning (fixed in harness v2). Benches used to .include the entire model file, so one malformed line anywhere in a vendor library killed every part defined in it — measured: 2101 load failures from just 102 files, 70 of which failed at 100%. Benches now embed a minimal extracted deck (the target block + its dependencies + file-scope .param, ASCII-sanitized), which also fixes non-UTF-8 decks and unbalanced .subckt/.ends. Internal helper subckts that need caller-supplied parameters are reported as untestable-generic, never a false FAILS-TO-LOAD.

Bootstrap a new project

bash
skidl-eda-bootstrap MyBoard --generate

Scaffolds a fresh project folder (a starter design, the design-circuit skill, MCP wiring, and a design log) and optionally runs the starter through generate().

The KiCad-10 symbol-library note

Do not set lib_search_paths["kicad10"] = ["."] + default_lib_paths(). When a process runs at or under a checkout that carries skidl's bundled tests/test_data, the resolver descends from "." and binds the bundled KiCad-6 libraries — silently shadowing KiCad-10 symbols and hiding KiCad-10-only parts (for example Amplifier_Operational:ADA4817-1ACP simply is not found). Call skidl_eda.setup_kicad10() instead; it points at the real KiCad-10 symbol directory only.

Canaries

canaries/sipm_tia/ contains a SiPM transimpedance amplifier authored natively in skidl, with drivers that exercise the full loop end to end:

bash
python canaries/sipm_tia/drive_validation.py  # equivalence | sim | gates | layout
python canaries/hitl_pcb/drive_hitl_pcb.py    # generate | edit | regenerate | PCB

Each canary is a slimmed builder (*_skidl.py) distilled from an end-to-end design in ../kicadprojects/, plus a drive_*.py acceptance script and a gated tests/test_*_canary.py (fast build assertions + a live-ngspice check that skips when the backend is absent). The set covers a spread of hard mechanisms:

bash
python canaries/royer_zvs/drive_royer.py      # self-oscillating ZVS, 24 V -> ~2 kV HV AC
python canaries/llc_resonant/drive_llc.py     # half-bridge LLC resonant converter (48 -> 12 V)
python canaries/dff_divider/drive_dff.py      # behavioral D-flip-flop /2 divider (no XSPICE)
python canaries/trig_pulser/drive_trig_pulser.py  # TRIGSW behavioral avalanche pulser
python canaries/hv_postreg/drive_hv_postreg.py    # closed-loop precision HV linear post-reg (12..200 V)
python canaries/hvllc/drive_hvllc.py          # HV LLC step-up w/ real IR2104 driver + LT1364 monitor
python canaries/funcgen/drive_funcgen.py      # relaxation-VCO square+sine generator (10-120 kHz)

License

MIT.

Parts

36
QtyValueFootprintReferences
3100uFC_1210_3225MetricCOUT1, COUT2, COUT3
22.2uFC_1210_3225MetricCIN1, CIN2
24.7uFC_0805_2012MetricCBIAS, CVCC
10.03R_2010_5025MetricRS
10.47uFC_0805_2012MetricCSS
110R_0805_2012MetricRG
110kR_0805_2012MetricRC
116kR_0805_2012MetricRFB1
11MR_0805_2012MetricRUV1
12.00kR_0805_2012MetricRFBS1
12.2nFC_0805_2012MetricCSN
120kR_0805_2012MetricRSN
122.1kR_0805_2012MetricRCOMP
12200pFC_1210_3225MetricCY
1274R_0805_2012MetricRLED
12kR_0805_2012MetricRBIAS
14.7nFC_0805_2012MetricCC
144.2kR_0805_2012MetricRUV2
147nFC_0805_2012MetricCCOMP
15.6kR_0805_2012MetricRFB2
16.19kR_0805_2012MetricRFBS2
163.4kR_0805_2012MetricRT
1BAS516D_SOD-123DAUX
1ES1DD_SMBDSN
1FDC2512TO-252-2M1
1LT3758MSOP-10-1EP_3x3mm_P0.5mm_EP1.68x1.88mmU1
1PA1277NLTransformer_Wuerth_750315371T1
1PS2801-1DIP-4_W7.62mmU2
1TL431SOT-23U3
1UPS840D_SMCDOUT
1VIN_36-72VTerminalBlock_Xinya_XY308-2.54-2P_1x02_P2.54mm_HorizontalJ1
1VOUT_3V3_3A_ISOTerminalBlock_Xinya_XY308-2.54-2P_1x02_P2.54mm_HorizontalJ2

More from freudenthal/skidl-eda

5
  • 2 layers48 × 36 mmLt8710 sepic manual, the printed circuit board in 3D

    Lt8710 sepic manual

    freudenthal/skidl-eda

    skidl-eda: AI circuit-design loop harness on the skidl stack

    35 parts
  • 2 layers38.6 × 39.8 mmLtc1871 dual sepic manual, the printed circuit board in 3D

    Ltc1871 dual sepic manual

    freudenthal/skidl-eda

    skidl-eda: AI circuit-design loop harness on the skidl stack

    27 parts
  • 2 layers36.4 × 38.6 mmLt3844 buck manual, the printed circuit board in 3D

    Lt3844 buck manual

    freudenthal/skidl-eda

    skidl-eda: AI circuit-design loop harness on the skidl stack

    25 parts
  • 2 layers42 × 34 mmLt3758 boost hv manual, the printed circuit board in 3D

    Lt3758 boost hv manual

    freudenthal/skidl-eda

    skidl-eda: AI circuit-design loop harness on the skidl stack

    23 parts
  • 2 layers36.6 × 27.7 mmLtc1871 sepic manual, the printed circuit board in 3D

    Ltc1871 sepic manual

    freudenthal/skidl-eda

    skidl-eda: AI circuit-design loop harness on the skidl stack

    20 parts

Similar boards

  • 2 layers139.2 × 95.6 mmIGBT DRIVER, the printed circuit board in 3D

    IGBT DRIVER

    EmadBahra/open-source-IGBT-gate-driver

    This is a beta version and it's not tested yet, so use it at your own risk under GPL v3

    240 parts5
  • 2 layers136 × 88 mmVayuO2, the printed circuit board in 3D

    VayuO2

    wyolum/vayuO2

    controller board for oxygen concentrator

    180 parts2
  • 2 layers187.5 × 45 mmGamma spectrometer, the printed circuit board in 3D

    Gamma spectrometer

    Motokichirou/gamma-spectrometer

    NaI(Tl) gamma spectrometer: STM32G474 + R1307 PMT + 4-board stack, KiCad schematics, LTspice simulations

    231 parts
  • 2 layers70 × 40 mmPOE, the printed circuit board in 3D

    POE

    reportingsjr/rfidBoard

    RFID/NFC board with ethernet+PoE with numerous I/Os.

    139 parts16
  • 4 layers94 × 140 mmPower, the printed circuit board in 3D

    Power

    LokiMetaSmith/handheld-scanner

    A handheld version of the PlasticScanner

    131 parts5
  • 2 layers35.2 × 17.9 mmBluz lcd v1, the printed circuit board in 3D

    Bluz lcd v1

    Maniak003/BluZ

    Scintillation gamma-spectrometer

    97 parts3GPL-3.0

Questions

How big is the Lt3758 iso flyback manual PCB?

It measures 52 × 36 mm and has 2 copper layers, 1.6 mm thick.

What parts does the Lt3758 iso flyback manual use?

36 parts, built around the PS2801-1, TL431, BAS516 and ES1D. The full list of its parts is on this page, with links to each part's symbol and footprint where PCBKit's library has them.

Where can I download the Lt3758 iso flyback manual KiCad files?

From the freudenthal/skidl-eda repository on GitHub, at the commit this page was made from: the board is canaries/lt3758_iso_flyback/lt3758_iso_flyback_manual.kicad_pcb. PCBKit opens the board in the browser, with nothing to install.

Can I use the Lt3758 iso flyback manual design in my own project?

Its repository states no licence, so its author keeps all rights: ask freudenthal before reusing the design.