diff --git a/doc/PDL.md b/doc/PDL.md
index 6989e82..991450e 100644
--- a/doc/PDL.md
+++ b/doc/PDL.md
@@ -4,6 +4,8 @@ A `.pdl` file describes a circuit part as data: its artwork, its pins, the
 properties a user can edit, and how it behaves in a simulation. Parts written
 this way need no Dart and no rebuild — drop the file and its SVG into
 `packages/pinbench_parts/assets/parts/<id>/` and it appears in the palette.
+A part can also take its drawing from a Dart painter instead of an SVG, and
+keep everything else as data — see [PAINTER](#painter).
 
 This exists because most parts do not need bespoke drawing code. A sensor, a
 module, a passive component: a photograph-accurate body from an SVG, a few
@@ -21,15 +23,22 @@ shipped parts and draws them.
 
 | Part | Exercises |
 | --- | --- |
-| `ldr` — photoresistor | `PHYSICS resistor` driven by a property |
+| `ldr` — photoresistor | `PHYSICS resistor` driven by a property; a `PAINTER` body and an `ALIAS` |
 | `thermistor` — 10k NTC | an exponential curve (`exp`) over two steps of state |
 | `slide_switch` — SPST | a boolean property, and `visual.*` driving a shape |
-| `cr2032` — coin cell | `PHYSICS voltageSource` |
-| `diode_1n4148` | `PHYSICS` only — no rules at all |
+| `cr2032` — coin cell | `PHYSICS voltageSource`; a `PAINTER` body |
+| `capacitor_electrolytic` — polarized | `PHYSICS capacitor` driven by a µF property; a `PAINTER` body |
+| `diode_1n4148` — switching | `PHYSICS` only — no rules at all; a `PAINTER` body |
+| `diode_1n4007` — rectifier, `diode_1n5819` — Schottky | `PHYSICS diode` with each part's own model numbers; one `PAINTER` shared by three parts |
 | `pir_sensor` — PIR motion | `LOGIC` — a one-shot needing a clock |
 | `tmp36`, `lm35` — analog temperature | `PHYSICS voltageSource` driven by a property, read by `analogRead` |
 | `soil_moisture` — capacitive probe | an inverted, offset output range in two steps of state |
-| `battery_9v` | `PHYSICS voltageSource`, like the coin cell |
+| `battery_9v` | `PHYSICS voltageSource`, like the coin cell; a `PAINTER` body |
+| `transistor` — seven types, TO-92 and TO-220 | `CONFIGURATION` — one part picked by its Type: `PHYSICS npn`/`pnp`/`nmos`/`pmos`/`npnDarlington`, power MOSFETs with their own `vto` and `kp` |
+| `slide_switch_spdt` — SPDT | `PHYSICS spdt` thrown by an `enum` property; a `PAINTER` that slides its lever to match |
+| `seven_segment` — common cathode | `PHYSICS ledArray` of eight dies and two tied cathode pins; `LOGIC` into `STATE` per segment; a `PAINTER` that lights each |
+| `ir_receiver` — VS1838B | `PHYSICS resistor` only — its internal pull-up; the IR Remote part's presses arrive on OUT as timed NEC codes, played in by the engine |
+| `rgb_led` — common cathode | `PHYSICS rgbLed`, the `led_array` `LOGIC` reading a current per pin into `STATE`, and a `PAINTER` that lights up from that state |
 | `bh1750` — light, I²C | `LOGIC` serving a pointer-less register bank; opcodes tracked in `STATE` |
 | `mpu6050` — accelerometer + gyro, I²C | `LOGIC` serving registers the sketch configures; an address set by wiring AD0 |
 | `ds1307` — real-time clock, I²C | `LOGIC` keeping time on the simulated clock; an `enum` property |
@@ -37,24 +46,26 @@ shipped parts and draws them.
 
 ## A complete example
 
-This is the part shipped at `assets/parts/ldr/ldr.pdl`. Nothing else is
-needed to make a working photoresistor.
+This is the part shipped at `assets/parts/ldr/ldr.pdl`. Everything about how
+it behaves is here; the only Dart it leans on is its drawing, the `ldr`
+painter.
 
 ```pdl
-# Photoresistor (LDR) — resistance falls as light rises.
+# LDR (photoresistor) — resistance falls as light rises.
 
-PART "Photoresistor"
+PART "LDR"
+ALIAS "Photoresistor"
 ID ldr
 CATEGORY sensors
 DESCRIPTION "Light-dependent resistor"
 
-SIZE 12.7mm 6.35mm
-SVG "ldr.svg"
+SIZE 56px 52px
+PAINTER ldr
 
 PINS
   # id  x      y      role     label
-  a     4px    20px   passive  "A"
-  b     68px   20px   passive  "B"
+  a     20px   52px   passive  "A"
+  b     36px   52px   passive  "B"
 
 PROPERTIES
   darkResistance  number  1000000  unit:"Ω"  label:"Dark resistance"
@@ -104,18 +115,80 @@ body sizes so the part is drawn the size the real thing is.
 | `ID <id>` | yes | Stable key. **Permanent** — see below. |
 | `SIZE <w> <h>` | yes | Footprint. |
 | `SVG "<path>"` | yes¹ | Artwork, relative to this file. |
+| `PAINTER <name>` | yes¹ | Draws the body with a registered Dart painter — see [PAINTER](#painter). |
+| `ALIAS "<name>"` | no | Another name the part answers to. Repeatable. |
 | `CATEGORY <name>` | no | Palette group (`sensors`, `basic`, `actuators`, …). |
 | `DESCRIPTION "<text>"` | no | Palette tooltip. |
 | `ORIGIN <x> <y>` | no | Part origin inside the footprint. Defaults to the centre. |
 | `LOGIC <name>` | no | Names a Dart behaviour — see [LOGIC](#logic). |
+| `CONFIGURATION <property> "<option>"` | no | Starts one configuration of a part with several — see [CONFIGURATION](#configuration). |
 
-¹ Either `SVG` or a `VISUALS` section. A part with neither draws nothing and
-is rejected.
+¹ One of `SVG`, `PAINTER` or a `VISUALS` section. A part with none draws
+nothing and is rejected; `SVG` and `PAINTER` together are rejected too, since
+both would draw the body.
+
+`ALIAS` is for renames. The palette search matches an alias, and so does a
+`.cdl` type token, so a file saved under the old name still loads — and is
+written back under the new one. The LDR shipped as `Photoresistor`.
 
 > **`ID` is permanent.** It is stored as `definitionId` on every placed
 > component in every saved `.cdl`. Changing it orphans them all. The name can
 > change freely; the id cannot.
 
+## CONFIGURATION
+
+One part in several configurations, picked by a property — the way one LED is
+any colour and one resistor any value, except that each configuration may
+differ in everything: size, pins, drawing, physics. The bundled `transistor`
+is NPN, PNP, a MOSFET or a TO-220 power part by its Type:
+
+```
+PART "Transistor"
+ID transistor
+CATEGORY basic
+
+PROPERTIES
+  type  enum  "NPN (2N3904)"  options:"NPN (2N3904),N-MOSFET (2N7000)"  label:"Type"
+
+CONFIGURATION type "NPN (2N3904)"
+ID transistor_npn
+ALIAS "2N3904"
+SIZE 40px 72px
+PAINTER transistor_npn
+PINS
+  collector 4px   68px  passive  "C"
+  base      20px  68px  passive  "B"
+  emitter   36px  68px  passive  "E"
+PHYSICS npn
+  c = collector
+  b = base
+  e = emitter
+
+CONFIGURATION type "N-MOSFET (2N7000)"
+ID transistor_nmos
+…
+```
+
+Everything before the first `CONFIGURATION` is shared. Each block runs to the
+next, and is read as the shared lines followed by its own: it adds pins,
+properties, rules and parameters to what is shared, and its single-value
+directives — `SIZE`, `PAINTER`, `DESCRIPTION` — take the place of shared ones.
+
+- The property must be an `enum` declared in the shared part, with a
+  `CONFIGURATION` for every option and none for anything else.
+- Every configuration needs an **`ID` of its own**: it is what a placed part
+  saves, and is as permanent as any other. The shared `ID` names the part as a
+  whole.
+- The palette lists the part once, as the configuration for the property's
+  default, and finds it by any configuration's `ALIAS`.
+
+Changing the property on the canvas swaps the placed part for that
+configuration. Each wire moves to the pin with the same id, or else to the pin
+in the same place in the new `PHYSICS` mapping — so listing every
+configuration's nodes in the same order (`c`, `b`, `e` and `d`, `g`, `s`) is
+what turns a collector into a drain. A wire whose pin has no counterpart is
+removed, and one undo brings the part and its wires back.
+
 ## PINS
 
 ```
@@ -246,8 +319,9 @@ bad rule stops the part loading rather than surfacing as a wrong number later.
 
 ## VISUALS
 
-Vector shapes drawn **over** the SVG. Use these only for what changes; a
-static body belongs in the artwork.
+Vector shapes drawn **over** the body, whether that is an SVG or a
+`PAINTER`. Use these only for what changes; a static body belongs in the
+artwork.
 
 ```
 VISUALS
@@ -281,6 +355,43 @@ An attribute value cannot contain spaces unless it is quoted, because
 attributes are single tokens — so a multi-term expression needs quoting:
 `color:"lerp(#000, #fff, state.x)"`.
 
+## PAINTER
+
+A body can be drawn by Dart instead of an SVG, while the part stays a `.pdl`:
+
+```
+PAINTER ldr
+```
+
+The name is looked up in `PartPainterRegistry` in `pinbench_parts`, which maps
+it to a painter. That painter draws only the body: it is scaled onto `SIZE`,
+`VISUALS` still draw over it, and its pins, properties, behaviour and physics
+are all this file's. Only the drawing is code.
+
+This is the shape to reach for when the artwork comes from a design tool as
+vector paths rather than as an SVG file. `battery_9v`, `cr2032`,
+`capacitor_electrolytic`, the diodes, `ir_receiver`, `ldr`, `rgb_led` and the transistors were drawn
+in Figma, one layer per colour, and converted to Flutter paths with the
+Flutter Da Vinci plugin; their painters (`battery_9v_painter.dart`,
+`cr2032_painter.dart`, `electrolytic_capacitor_painter.dart`,
+`axial_diode_painter.dart`, `ldr_painter.dart`, `rgb_led_painter.dart`,
+`transistor_painter.dart`, `to220_painter.dart`) are those paths, drawn through
+the `PathArtPainter` mixin. A painter also receives the placed part's
+properties and state, so it can draw what changes too: `rgb_led` mixes its
+glow from the `red`, `green` and `blue` state its logic writes. One painter can serve several parts: the TO-92
+transistors share a body and register a `transistor_<kind>` name each, and the
+TO-220 parts a `to220_<kind>`.
+The part itself is still the `.pdl` beside them.
+
+A painter whose body is smaller than `SIZE` reports it through `bodyRect`, so
+the part is hit on the body and not across its whole bounds. An unregistered
+name is not fatal — the part loads and draws its `VISUALS` — and the
+bundled-parts test fails on it.
+
+Use `PAINTER` for a static body. A part whose look is the simulation — a
+servo horn, a display's pixels — is still better as a built-in part with a
+hand-written painter.
+
 ## PHYSICS
 
 How the part participates in the analog solve.
@@ -300,14 +411,63 @@ SPICE node name to a pin id. Mapping to an undeclared pin is a parse error.
 | `resistor` | `R_…` | `resistance` | yes |
 | `voltageSource` (`vsource`) | `V_…` | `voltage` | yes |
 | `capacitor` | `C_…` | `capacitance` | yes |
-| `diode` | `D_…` | — | no |
+| `diode` | `D_…` | model parameters (`is`, `n`) | no |
 | `currentSource` (`isource`) | — | — | not yet built |
+| `npn`, `pnp` | `Q_…` | model parameters | no |
+| `nmos`, `pmos` | `M_…` | model parameters | no |
+| `npnDarlington`, `pnpDarlington` | two `Q_…` | model parameters, `r1`, `r2` | no |
+| `rgbLed` | three `D_…` | — | no |
+| `spdt` | two `R_…` | `position` (0 = `a`, 1 = `b`) | yes |
+| `ledArray` | one `D_…` per mapped die | model parameters (`is`, `n`) | no |
 
 A matching `physics.<param>` rule overrides the static parameter and is pushed
 into ngspice each frame via `alter`, the same mechanism the Arduino's pin
 sources use. That avoids rebuilding the circuit, which would reset every node
 voltage mid-run.
 
+### Transistors
+
+A transistor maps three nodes: `c`, `b`, `e` for a bipolar one, `d`, `g`, `s`
+for a MOSFET, whose body is tied to its source. Its numeric parameters are the
+SPICE `.model` parameters, applied over the engine's defaults — a 2N3904 for
+`npn`, a 2N3906 for `pnp`, and level-1 MOSFETs near a 2N7000 and its
+P-channel counterpart:
+
+```
+PHYSICS npn
+  c = collector
+  b = base
+  e = emitter
+  bf = 300      # a higher-gain part than the default
+```
+
+A Darlington pair maps the same three nodes as one bipolar transistor and is
+built as two, the first driving the second's base, with a resistor across each
+base-emitter junction as in a TIP120: `r1` (8 kΩ) across the driver, `r2`
+(120 Ω) across the output. Its other parameters apply to both transistors.
+
+An `rgbLed` maps each colour's anode — `r`, `g`, `b` — and the shared cathode
+`k`. The red die drops about 2 V at 20 mA, green and blue about 3 V, and each
+is measured like a single LED, so a `LOGIC` reads a colour's current with
+`context.spice.pinCurrent('<its anode pin>')`. The bundled part uses the
+`led_array` logic below, which turns those into `state.red`, `state.green`
+and `state.blue`, and its painter reads them to light the lens.
+
+An `ledArray` generalises that to any number of dies on one cathode: each
+role but `k` maps a die's anode — a 7-segment display maps `a` to `g` and
+`dp` — and a second cathode pin maps `k2`, tied to `k` inside the part as it
+is in the real one. The `led_array` logic writes each die's brightness into
+`STATE` under its pin's id.
+
+A power MOSFET is the same `nmos`/`pmos` element with bigger numbers: the
+transistor's `power_nmos` and `power_pmos` configurations declare `vto` and
+`kp` near an IRLZ44N and an IRF9540N rather than adding a type.
+
+The solve is an operating point, so only DC parameters matter (`is`, `bf`,
+`br`, `vaf`, … and `vto`, `kp`, `lambda`). A MOSFET's gate is tied to its
+source through 1 GΩ so that a gate left unwired is off rather than an
+unsolvable floating node.
+
 ## LOGIC
 
 Some parts cannot be a rule. `BEHAVIOR` is total by design — no loops, no
@@ -504,7 +664,8 @@ mechanism replaced a per-part frame updater in the engine with.
 
 ## Assets
 
-A part is a directory: `assets/parts/<id>/<id>.pdl` plus its SVG. Add the
+A part is a directory: `assets/parts/<id>/<id>.pdl` plus its SVG, if it draws
+with one. Add the
 directory to `packages/pinbench_parts/pubspec.yaml` under `flutter: assets:`.
 
 A relative `SVG "foo.svg"` resolves next to the `.pdl` that named it, so a part
@@ -554,7 +715,8 @@ Honest about what is not there yet:
 
 1. `mkdir packages/pinbench_parts/assets/parts/<id>/`
 2. Draw the body as an SVG. Its viewBox is scaled onto `SIZE`, so the units
-   inside it do not matter — only the aspect.
+   inside it do not matter — only the aspect. Or, for vector art exported as
+   paths, register a painter and name it with [`PAINTER`](#painter).
 3. Write `<id>.pdl`. Put pins on the lattice (`4, 20, 36, …`).
 4. Declare the directory in `packages/pinbench_parts/pubspec.yaml`.
 5. `cd packages/pinbench_parts && flutter test` — the bundled-parts test will tell
diff --git a/lib/src/part_definition.dart b/lib/src/part_definition.dart
index 746971e..2fff71c 100644
--- a/lib/src/part_definition.dart
+++ b/lib/src/part_definition.dart
@@ -5,8 +5,8 @@ import 'geometry.dart';
 import 'pin.dart';
 import 'resistance.dart';
 
-/// A part described entirely by data — a `.pdl` file — rather than by a
-/// hand-written Dart painter.
+/// A part described by data — a `.pdl` file — rather than as a built-in part
+/// in Dart.
 ///
 /// This is how the catalog grows without code. A definition carries everything
 /// needed to place, draw, wire and simulate a component: its [visual] (an SVG
@@ -38,6 +38,12 @@ class const PartDefinition({
 
   /// Palette grouping, matching `PartCategory` names.
   final String? category,
+
+  /// Other names the part goes by — `Photoresistor` for an `LDR`. The palette
+  /// search matches them, and so does a `.cdl` type token, which is what keeps
+  /// a file written under a part's old name loading after a rename. The part
+  /// is always written under [name].
+  final List<String> aliases = const [],
   final Map<String, PropertyDef> properties = const {},
   final Map<String, StateDef> state = const {},
 
@@ -49,6 +55,11 @@ class const PartDefinition({
   /// practice, though nothing forbids both.
   final String? logic,
   final SpiceModelDef? spiceModel,
+
+  /// Which configuration of a part this is, when its `.pdl` describes one
+  /// part in several — a transistor that is NPN, PNP or a MOSFET depending on
+  /// its `type`. Null for a part with one configuration.
+  final PartConfiguration? configuration,
 }) {
   /// The pin with [id], or null. Linear because parts have a handful of pins;
   /// a map would cost more to build than it saves.
@@ -75,10 +86,11 @@ class const PartDefinition({
 
 /// How a [PartDefinition] is drawn.
 ///
-/// Either an [svgPath] — the common case for the static parts this format
-/// exists to make cheap — or a list of vector [shapes] for artwork that has to
-/// react to state. Both may be present: shapes draw over the SVG, which is how
-/// a static body gets a lit LED or a moving needle on top.
+/// The body comes from an [svgPath] — the common case for the static parts this
+/// format exists to make cheap — or from a [painter], a Dart painter the app
+/// registers under that name. Vector [shapes] draw over either, for artwork
+/// that has to react to state: that is how a static body gets a lit LED or a
+/// moving needle on top. A part may also be shapes alone.
 @immutable
 class const VisualDef({
   /// Footprint in canvas pixels. Authored in millimetres and converted at
@@ -89,6 +101,11 @@ class const VisualDef({
   /// Path of an SVG, resolved against the `assetDirectory` the file was
   /// parsed with — for the bundled parts, a Flutter asset key.
   final String? svgPath,
+
+  /// Names a painter registered in the app that draws the body instead of an
+  /// SVG — vector paths generated from a design tool, say. Only the drawing
+  /// is Dart; pins, properties and behaviour stay in the `.pdl`.
+  final String? painter,
   final List<ShapeDef> shapes = const [],
 
   /// Where the part's origin sits inside that footprint.
@@ -178,6 +195,28 @@ class const BehaviorRule({
   String toString() => '${target.name}.$key = $source';
 }
 
+/// One configuration of a part whose `.pdl` describes several, chosen by a
+/// property: the transistor whose `type` is `NPN`, say.
+///
+/// Every configuration is a complete [PartDefinition] with an ID of its own,
+/// which is what a placed part saves; they share the part's [family] ID, and
+/// differ in [value] — the option of the [property] each answers to.
+@immutable
+class const PartConfiguration({
+  /// The part's own ID, shared by all its configurations.
+  required final String family,
+
+  /// The enum property that picks a configuration.
+  required final String property,
+
+  /// The option of [property] this configuration is.
+  required final String value,
+
+  /// Whether this is the configuration a freshly placed part starts as: the
+  /// one for [property]'s default.
+  required final bool isDefault,
+});
+
 /// The type of an editable property, which decides its editor widget.
 enum PdlPropertyType() {
   number,
@@ -236,6 +275,40 @@ enum SpiceComponentType() {
   /// something a part could assemble.
   potentiometer,
 
+  /// Bipolar transistors, mapped `c`, `b`, `e`. Numeric `PHYSICS` parameters
+  /// are SPICE model parameters (`bf = 300`) over the engine's defaults.
+  npn,
+  pnp,
+
+  /// Darlington pairs — two bipolar transistors, the first driving the
+  /// second's base, with the TIP120's internal base-emitter resistors (`r1`
+  /// across the driver, `r2` across the output). Mapped `c`, `b`, `e`.
+  npnDarlington,
+  pnpDarlington,
+
+  /// A common-cathode RGB LED: three diodes, anodes mapped `r`, `g`, `b` and
+  /// their shared cathode `k`, each measured like a single LED so a logic can
+  /// read the current through every colour at its pin.
+  rgbLed,
+
+  /// A single-pole double-throw switch: the common `c` connected to `a` or to
+  /// `b`. Two resistors, closed and open, swapped by one alterable value,
+  /// `position` — 0 for `a`, 1 for `b` — so a `physics.position` rule throws
+  /// it mid-run.
+  spdt,
+
+  /// Any number of LEDs sharing a cathode — a 7-segment display, a bar graph.
+  /// Every mapped role but `k` is a die from that pin to the cathode `k`,
+  /// measured like a single LED; any other role starting `k` (`k2`) is a
+  /// second cathode pin, tied to the first. Numeric `is` and `n` set the
+  /// dies' model; without them they drop about 2 V, as red ones do.
+  ledArray,
+
+  /// Enhancement MOSFETs, mapped `d`, `g`, `s`, the body tied to the source.
+  /// Numeric parameters are level-1 SPICE model parameters (`vto`, `kp`).
+  nmos,
+  pmos,
+
   none,
 }
 
@@ -290,6 +363,15 @@ class const SpiceModelDef({
     'voltageSource' || 'vsource' => SpiceComponentType.voltageSource,
     'capacitor' => SpiceComponentType.capacitor,
     'currentSource' || 'isource' => SpiceComponentType.currentSource,
+    'npn' => SpiceComponentType.npn,
+    'pnp' => SpiceComponentType.pnp,
+    'npnDarlington' => SpiceComponentType.npnDarlington,
+    'pnpDarlington' => SpiceComponentType.pnpDarlington,
+    'rgbLed' => SpiceComponentType.rgbLed,
+    'spdt' => SpiceComponentType.spdt,
+    'ledArray' => SpiceComponentType.ledArray,
+    'nmos' => SpiceComponentType.nmos,
+    'pmos' => SpiceComponentType.pmos,
     _ => SpiceComponentType.none,
   };
 }
diff --git a/lib/src/pdl_parser.dart b/lib/src/pdl_parser.dart
index 40aad47..a0be877 100644
--- a/lib/src/pdl_parser.dart
+++ b/lib/src/pdl_parser.dart
@@ -28,11 +28,18 @@ class const PdlDiagnostic(
 }
 
 /// A parsed definition plus everything that went wrong reading it.
+///
+/// A file with `CONFIGURATION` blocks parses to one definition per
+/// configuration, all in [definitions]; [definition] is then the default one.
 @immutable
 class const PdlParseResult(
   final PartDefinition? definition,
-  final List<PdlDiagnostic> diagnostics,
-) {
+  final List<PdlDiagnostic> diagnostics, {
+  final List<PartDefinition>? configurations,
+}) {
+  /// Every definition the file produced: its configurations, or the one part.
+  List<PartDefinition> get definitions => configurations ?? [?definition];
+
   bool get hasErrors => diagnostics.any((d) => d.isError);
   Iterable<PdlDiagnostic> get errors => diagnostics.where((d) => d.isError);
 }
@@ -76,6 +83,201 @@ class PdlParser {
   /// resolved against — the directory the `.pdl` itself came from — so a part
   /// can be moved without editing it.
   static PdlParseResult parse(String source, {String assetDirectory = ''}) {
+    final lines = source.split('\n');
+    final starts = [
+      for (var i = 0; i < lines.length; i++)
+        if (_configurationHeader.hasMatch(_stripComment(lines[i]))) i,
+    ];
+    return starts.isEmpty
+        ? _parseOne(source, assetDirectory)
+        : _parseConfigured(lines, starts, assetDirectory);
+  }
+
+  static final _configurationHeader = RegExp(r'^CONFIGURATION(\s|$)');
+
+  /// A part described in several configurations, each one `CONFIGURATION`
+  /// block after what they all share:
+  ///
+  ///     PART "Transistor"
+  ///     ID transistor
+  ///     PROPERTIES
+  ///       type  enum  NPN  options:"NPN,PNP"  label:"Type"
+  ///
+  ///     CONFIGURATION type "NPN"
+  ///     ID transistor_npn
+  ///     PINS
+  ///       …
+  ///
+  ///     CONFIGURATION type "PNP"
+  ///     ID transistor_pnp
+  ///     …
+  ///
+  /// Each block is read as the shared lines followed by its own, so it adds
+  /// pins, rules and parameters to what is shared, and its single-value
+  /// directives — `SIZE`, `PAINTER`, `ID` — take the place of shared ones.
+  /// The other blocks' lines are blanked rather than removed, so every
+  /// diagnostic keeps the line number it has in the file.
+  static PdlParseResult _parseConfigured(
+    List<String> lines,
+    List<int> starts,
+    String assetDirectory,
+  ) {
+    // Keyed by what they say: a problem in a shared line is found once per
+    // configuration, and reported once.
+    final diagnostics = <String, PdlDiagnostic>{};
+    void report(PdlDiagnostic d) => diagnostics.putIfAbsent('$d', () => d);
+    void error(int line, String message) => report(PdlDiagnostic(line, message));
+
+    bool isId(String line) => RegExp(r'^ID(\s|$)').hasMatch(_stripComment(line));
+    final sharedEnd = starts.first;
+    final family = [
+      for (final line in lines.take(sharedEnd))
+        if (isId(line)) _unquote(_tokenize(_stripComment(line).trim()).skip(1).join(' ')),
+    ].lastOrNull;
+    if (family == null) {
+      error(0, 'missing ID — a configured part needs one of its own, shared by its configurations');
+    }
+
+    final parsed = <(int, String, PartDefinition)>[];
+    // Every option a block is written for, whether or not it parsed: one
+    // that failed already has its own error, not a missing one.
+    final written = <String>{};
+    String? selector;
+    for (var k = 0; k < starts.length; k++) {
+      final header = starts[k];
+      final end = k + 1 < starts.length ? starts[k + 1] : lines.length;
+      final tokens = _tokenize(_stripComment(lines[header]).trim());
+      if (tokens.length < 3) {
+        error(header + 1, 'CONFIGURATION needs a property and its value: CONFIGURATION type "NPN"');
+        continue;
+      }
+      final property = tokens[1];
+      final value = _unquote(tokens.skip(2).join(' '));
+      if (selector != null && property != selector) {
+        error(header + 1, 'every CONFIGURATION must choose by the same property, "$selector"');
+        continue;
+      }
+      selector = property;
+      written.add(value);
+
+      final ownId = lines.sublist(header + 1, end).any(isId);
+      if (!ownId) {
+        error(
+          header + 1,
+          'configuration "$value" needs an ID of its own — it is what a placed part saves',
+        );
+        continue;
+      }
+      final source = [
+        for (var i = 0; i < lines.length; i++)
+          if (i < sharedEnd)
+            (isId(lines[i]) ? '' : lines[i])
+          else if (i > header && i < end)
+            lines[i]
+          else
+            '',
+      ].join('\n');
+      final result = _parseOne(source, assetDirectory);
+      for (final d in result.diagnostics) {
+        // A file-level problem belongs to the configuration that has it.
+        report(
+          d.line == 0
+              ? PdlDiagnostic(
+                  header + 1,
+                  'in configuration "$value": ${d.message}',
+                  isError: d.isError,
+                )
+              : d,
+        );
+      }
+      if (result.definition case final definition?) parsed.add((header + 1, value, definition));
+    }
+
+    final selectorDef = parsed.isEmpty ? null : parsed.first.$3.properties[selector];
+    if (parsed.isNotEmpty &&
+        (selectorDef == null || selectorDef.type != PdlPropertyType.enumeration)) {
+      error(
+        starts.first + 1,
+        'CONFIGURATION chooses by "$selector", which PROPERTIES must declare as an enum',
+      );
+    }
+    final options = selectorDef?.options ?? const <String>[];
+    final seen = <String>{};
+    for (final (line, value, definition) in parsed) {
+      if (!options.contains(value)) {
+        error(line, '"$value" is not one of $selector\'s options: ${options.join(', ')}');
+      }
+      if (!seen.add(value)) error(line, 'a second CONFIGURATION for "$value"');
+      if (definition.id == family) {
+        error(line, 'configuration "$value" has the part\'s own ID — give it one of its own');
+      }
+    }
+    for (final option in options) {
+      if (!written.contains(option)) error(0, '$selector "$option" has no CONFIGURATION');
+    }
+    final ids = <String>{};
+    for (final (line, _, definition) in parsed) {
+      if (!ids.add(definition.id)) error(line, 'duplicate configuration ID "${definition.id}"');
+    }
+
+    final sorted = diagnostics.values.toList()..sort((a, b) => a.line.compareTo(b.line));
+    if (sorted.any((d) => d.isError)) return PdlParseResult(null, sorted, configurations: const []);
+
+    final configurations = [
+      for (final option in options)
+        for (final (_, value, definition) in parsed)
+          if (value == option)
+            _asConfiguration(
+              definition,
+              PartConfiguration(
+                family: family!,
+                property: selector!,
+                value: value,
+                isDefault: value == selectorDef!.defaultValue,
+              ),
+            ),
+    ];
+    return PdlParseResult(
+      configurations.firstWhere((d) => d.configuration!.isDefault),
+      sorted,
+      configurations: configurations,
+    );
+  }
+
+  /// [definition] as [configuration]: its choosing property defaults to the
+  /// configuration's own value, so a part placed as this one shows it.
+  static PartDefinition _asConfiguration(
+    PartDefinition definition,
+    PartConfiguration configuration,
+  ) {
+    final selector = definition.properties[configuration.property]!;
+    return PartDefinition(
+      id: definition.id,
+      name: definition.name,
+      visual: definition.visual,
+      pins: definition.pins,
+      description: definition.description,
+      category: definition.category,
+      aliases: definition.aliases,
+      properties: {
+        ...definition.properties,
+        configuration.property: PropertyDef(
+          type: selector.type,
+          defaultValue: configuration.value,
+          label: selector.label,
+          unit: selector.unit,
+          options: selector.options,
+        ),
+      },
+      state: definition.state,
+      behavior: definition.behavior,
+      logic: definition.logic,
+      spiceModel: definition.spiceModel,
+      configuration: configuration,
+    );
+  }
+
+  static PdlParseResult _parseOne(String source, String assetDirectory) {
     final diagnostics = <PdlDiagnostic>[];
     void error(int line, String message) => diagnostics.add(PdlDiagnostic(line, message));
     void warn(int line, String message) =>
@@ -90,6 +292,8 @@ class PdlParser {
     double? height;
     PdlPoint? origin;
     String? svgPath;
+    String? painter;
+    final aliases = <String>[];
 
     final pins = <PinDef>[];
     final properties = <String, PropertyDef>{};
@@ -144,6 +348,21 @@ class PdlParser {
           case 'LOGIC':
             logic = tokens.length > 1 ? _unquote(tokens[1]) : null;
             continue;
+          case 'PAINTER':
+            if (tokens.length < 2) {
+              error(lineNumber, 'PAINTER needs a name');
+            } else {
+              painter = _unquote(tokens[1]);
+            }
+            continue;
+          case 'ALIAS':
+            final alias = _unquote(tokens.skip(1).join(' '));
+            if (alias.isEmpty) {
+              error(lineNumber, 'ALIAS needs a name');
+            } else {
+              aliases.add(alias);
+            }
+            continue;
           case 'SIZE':
             if (tokens.length < 3) {
               error(lineNumber, 'SIZE needs a width and a height');
@@ -219,8 +438,11 @@ class PdlParser {
       error(0, 'missing ID — it is the stable key saved circuits refer to');
     }
     if (width == null || height == null) error(0, 'missing SIZE');
-    if (svgPath == null && shapes.isEmpty) {
-      error(0, 'a part needs either an SVG or a VISUALS section — nothing would be drawn');
+    if (svgPath == null && painter == null && shapes.isEmpty) {
+      error(0, 'a part needs an SVG, a PAINTER or a VISUALS section — nothing would be drawn');
+    }
+    if (svgPath != null && painter != null) {
+      error(0, 'SVG and PAINTER both draw the body — a part has one or the other');
     }
     if (pins.isEmpty) warn(0, 'no PINS — this part cannot be wired to anything');
 
@@ -243,9 +465,11 @@ class PdlParser {
         name: name!,
         description: description,
         category: category,
+        aliases: aliases,
         logic: logic,
         visual: VisualDef(
           svgPath: svgPath,
+          painter: painter,
           shapes: shapes,
           width: width!,
           height: height!,
diff --git a/test/pdl_configuration_test.dart b/test/pdl_configuration_test.dart
new file mode 100644
index 0000000..2b236cd
--- /dev/null
+++ b/test/pdl_configuration_test.dart
@@ -0,0 +1,139 @@
+import 'package:pinbench_pdl/pinbench_pdl.dart';
+import 'package:test/test.dart';
+
+/// One `.pdl` describing a part in several configurations — a transistor
+/// that is NPN or a MOSFET by its `type`.
+void main() {
+  const shared = '''
+PART "Switch"
+ID switch
+CATEGORY basic
+SVG "switch.svg"
+
+PROPERTIES
+  type  enum  "Bipolar"  options:"Bipolar,MOSFET"  label:"Type"
+  note  string  hi
+''';
+
+  const bipolar = '''
+CONFIGURATION type "Bipolar"
+ID switch_bjt
+ALIAS "BJT"
+SIZE 40px 72px
+PINS
+  collector 4px  68px passive "C"
+  base      20px 68px passive "B"
+  emitter   36px 68px passive "E"
+PHYSICS npn
+  c = collector
+  b = base
+  e = emitter
+''';
+
+  const mosfet = '''
+CONFIGURATION type "MOSFET"
+ID switch_fet
+SIZE 72px 88px
+PINS
+  gate   20px 84px passive "G"
+  drain  36px 84px passive "D"
+  source 52px 84px passive "S"
+PHYSICS nmos
+  d = drain
+  g = gate
+  s = source
+  vto = 2
+''';
+
+  test('each configuration is a whole part: what is shared, plus its own', () {
+    final result = PdlParser.parse('$shared\n$bipolar\n$mosfet');
+    expect(result.diagnostics, isEmpty, reason: result.diagnostics.join('\n'));
+    final [bjt, fet] = result.definitions;
+
+    expect([bjt.id, fet.id], ['switch_bjt', 'switch_fet']);
+    expect(bjt.name, 'Switch', reason: 'shared');
+    expect(fet.category, 'basic', reason: 'shared');
+    expect(fet.properties['note']?.defaultValue, 'hi', reason: 'shared');
+    expect(bjt.aliases, ['BJT'], reason: 'its own');
+    expect([fet.visual.width, fet.visual.height], [72, 88], reason: 'its own');
+    expect(fet.pins.map((p) => p.id), ['gate', 'drain', 'source']);
+    expect(fet.spiceModel?.type, SpiceComponentType.nmos);
+    expect(fet.spiceModel?.parameters, {'vto': 2});
+    expect(bjt.spiceModel?.parameters, isEmpty, reason: "the other's lines are not its own");
+  });
+
+  test('each knows which configuration of which part it is', () {
+    final result = PdlParser.parse('$shared\n$bipolar\n$mosfet');
+    final [bjt, fet] = result.definitions;
+    expect(bjt.configuration?.family, 'switch');
+    expect(bjt.configuration?.property, 'type');
+    expect([bjt.configuration?.value, fet.configuration?.value], ['Bipolar', 'MOSFET']);
+    expect([bjt.configuration?.isDefault, fet.configuration?.isDefault], [true, false]);
+    expect(result.definition, same(bjt), reason: 'the default one');
+    expect(
+      fet.properties['type']?.defaultValue,
+      'MOSFET',
+      reason: 'a part placed as this configuration shows it',
+    );
+  });
+
+  test('definitions are in the order the options list them', () {
+    final result = PdlParser.parse('$shared\n$mosfet\n$bipolar');
+    expect(result.definitions.map((d) => d.id), ['switch_bjt', 'switch_fet']);
+  });
+
+  group('is rejected with a reason when', () {
+    List<String> problems(String source) => [
+      for (final d in PdlParser.parse(source).errors) d.message,
+    ];
+
+    test('a configuration has no ID of its own', () {
+      expect(
+        problems('$shared\n$bipolar\n${mosfet.replaceFirst('ID switch_fet\n', '')}'),
+        contains(contains('"MOSFET" needs an ID of its own')),
+      );
+    });
+
+    test('an option has no configuration', () {
+      expect(problems('$shared\n$bipolar'), contains('type "MOSFET" has no CONFIGURATION'));
+    });
+
+    test('a configuration is for no option', () {
+      expect(
+        problems(
+          '$shared\n$bipolar\n$mosfet\n${mosfet.replaceAll('MOSFET', 'IGBT').replaceAll('switch_fet', 'switch_igbt')}',
+        ),
+        contains(contains('"IGBT" is not one of type\'s options')),
+      );
+    });
+
+    test('the choosing property is not an enum', () {
+      expect(
+        problems(
+          '$shared\n$bipolar\n$mosfet'.replaceFirst(
+            '  type  enum  "Bipolar"  options:"Bipolar,MOSFET"',
+            '  type  string  Bipolar',
+          ),
+        ),
+        contains(contains('which PROPERTIES must declare as an enum')),
+      );
+    });
+
+    test('a problem in one configuration names it, at its line', () {
+      final source = '$shared\n$bipolar\n${mosfet.replaceFirst('SIZE 72px 88px\n', '')}';
+      final missing = PdlParser.parse(source).errors.single;
+      expect(missing.message, 'in configuration "MOSFET": missing SIZE');
+      expect(source.split('\n')[missing.line - 1], 'CONFIGURATION type "MOSFET"');
+    });
+  });
+
+  test('a problem on a shared line is reported once, where it is', () {
+    final source = '$shared\n$bipolar\n$mosfet'.replaceFirst(
+      'CATEGORY basic',
+      'CATEGORY basic\nWAT',
+    );
+    final result = PdlParser.parse(source);
+    expect(result.errors.map((d) => d.message), ['unknown directive "WAT"']);
+    expect(source.split('\n')[result.errors.single.line - 1], 'WAT');
+  });
+}
diff --git a/test/pdl_parser_test.dart b/test/pdl_parser_test.dart
index 0887520..0592d0b 100644
--- a/test/pdl_parser_test.dart
+++ b/test/pdl_parser_test.dart
@@ -143,6 +143,14 @@ PHYSICS resistor
       expect(result.errors.map((e) => e.message).join(), contains('nothing would be drawn'));
     });
 
+    test('both an SVG and a PAINTER, which would fight over the body', () {
+      final result = parse(
+        pdl(head: 'PART "Thing"\nID thing\nSIZE 32px 16px\nSVG "t.svg"\nPAINTER thing'),
+      );
+      expect(result.errors.map((e) => e.message).join(), contains('one or the other'));
+      expect(result.definition, isNull);
+    });
+
     test('a behaviour rule writing undeclared state', () {
       final result = parse(pdl(body: 'PINS\n  a 4px 4px\n\nBEHAVIOR\n  state.ghost = 1'));
       expect(result.errors.map((e) => e.message).join(), contains('no STATE section declares'));
@@ -231,6 +239,52 @@ PHYSICS resistor
       expect(shapes[1].text.evaluate(context), 'state.x', reason: 'quoted stays literal');
     });
 
+    test('a transistor maps three pins and keeps its model parameters', () {
+      final result = parse(
+        pdl(
+          body:
+              'PINS\n  c 4px 4px\n  b 20px 4px\n  e 36px 4px\n\n'
+              'PHYSICS npn\n  c = c\n  b = b\n  e = e\n  bf = 300',
+        ),
+      );
+      expect(result.diagnostics, isEmpty, reason: result.diagnostics.join('\n'));
+      final model = result.definition!.spiceModel!;
+      expect(model.type, SpiceComponentType.npn);
+      expect(model.pinMapping, {'c': 'c', 'b': 'b', 'e': 'e'});
+      expect(model.parameters, {'bf': 300});
+      for (final name in [
+        'pnp',
+        'nmos',
+        'pmos',
+        'npnDarlington',
+        'pnpDarlington',
+        'rgbLed',
+        'spdt',
+        'ledArray',
+      ]) {
+        expect(SpiceModelDef.typeFromName(name).name, name);
+      }
+    });
+
+    test('a PAINTER draws the body in place of an SVG', () {
+      final result = parse(pdl(head: 'PART "Thing"\nID thing\nSIZE 32px 16px\nPAINTER thing'));
+      expect(result.diagnostics, isEmpty, reason: result.diagnostics.join('\n'));
+      expect(result.definition!.visual.painter, 'thing');
+      expect(result.definition!.visual.svgPath, isNull);
+    });
+
+    test('ALIAS may repeat, and keeps spaces inside quotes', () {
+      final result = parse(
+        pdl(
+          head:
+              'PART "LDR"\nID ldr\nSIZE 32px 16px\nSVG "t.svg"\n'
+              'ALIAS "Photoresistor"\nALIAS "Light sensor"',
+        ),
+      );
+      expect(result.diagnostics, isEmpty, reason: result.diagnostics.join('\n'));
+      expect(result.definition!.aliases, ['Photoresistor', 'Light sensor']);
+    });
+
     test('a relative SVG path resolves next to the .pdl that named it', () {
       final result = PdlParser.parse(
         pdl(),