Parcel & Scribe [wip]

Procedural block-to-lot subdivision for city-scale level design

Overview

Parcel is a general-purpose tool for subdividing polygons into lots. Scribe is the geometry-operations library it runs on, with plans to grow into a broader cutting toolkit; Parcel is its first customer. Both came out of building Grayworld II, where they sit between the block generator and the facade stage and turn city blocks into buildable lots: a block polygon goes in, a field of lots comes out. A single block moving through Parcel:

Tools

Houdini, VEX

Year

2025 — 2026

Scribe

Scribe is the shared library underneath Parcel: functions for measuring, classifying, and cutting polygons, with no assumptions about what those polygons represent. Every operation belongs to one of five families, and a single pass runs them in order:

• Analyze measures the polygon, classifies its edges, and writes facts about it.
• Select chooses what to act on.
• Strategy resolves intent into a concrete cut origin and direction.
• Split performs the polygon surgery and hands each child its inheritance.
• Verify decides whether the loop keeps going.

The important part is what Split carries. Each child inherits its parent’s frame axis and a lineage string recording where it came from, so every lot ends up with an address in the cut tree. Later stages read that address to tell which edge faces the street and which lots are siblings.

Scribe Verbs

Scribe Wrapper

The wrapper turns Scribe into a repeatable pass: route the active lots, run the configured Scribe operation, reseed the children, clean the loop, and merge the result back into the stream. This is the socket Parcel plugs into for each stage.

The captures below keep the same wrapper input and show repeated operations as compact 2x2 sheets.

Parcel

Parcel is the orchestration layer. Where Scribe supplies the operations, Parcel decides which to run, on what geometry, and in what order. It is one universal pass HDA: the five-stage chain wrapped so a whole block can be driven through it repeatedly, with per-lot state travelling along the geometry so a single loop handles corners, strips, and interiors without special-casing each.

Four verbs sit on top as presets, each a Scribe wrapper with the stages set for one intent:

• Peel cuts parallel to a boundary edge. This is how frontage bands come off.
• Divide makes repeated cuts along a locked axis. This is where rowhouse rhythm comes from.
• Bisect is a one-off cut from an arbitrary origin, used to rough in the parti before detail.
• Leave does nothing. The lot is already done.

Recipes

A recipe is a chain of verbs, written in a compact notation. P(d=0.3)x4 > D(w=0.15)x27 is four perimeter peels followed by twenty-seven frontage divisions: the rowhouse block. Only the arguments that matter to each verb appear, stages chain with >, and swapping the ending changes the character. Seed the last Divide into a single lineage and the same peels leave a ring around an uncut courtyard, the first block in the overview.

Eleven curated seeds anchor the language and fall into a few families: Bisect mosaics that walk from slab to dense field on an iteration dial, mosaics broken into strip rhythm, a band-peel-divide family that grades from one edge, the Peel-then-Divide rowhouse, and compound recipes layering several moves. They are the reference set everything else is measured against.

Automated Testing

Each Parcel stage exposes the same set of scribe_wrapper parameters, so the controls are readable on their own. The open question is which combinations produce which looks: rowhouse rhythm, mixed-width blocks, a courtyard left uncut — the block characters visible in aerial reference. Automated testing builds that vernacular, a working map from lever to shape, one batch at a time:

1. Canonicalize every recorded run into a notation signature.
2. Diff its outcome against an identity baseline, field by field.
3. Attribute the differences to specific elements of the notation.
4. Distill those into plain-language lever-to-shape claims.
5. Write predictions, then design a small batch to test them.
6. Misses become corrections, and corrections become new entries.

So far that is 329 recorded runs across 40 batches. Every claim is checked against the HDA’s designed contract, extracted from the wrapper VEX, and tagged by origin so a behavior the tool guarantees is never mistaken for one discovered by testing. A few that survived the loop: iterations act as a near-linear density dial, one recipe giving 191, 232, and 273 lots at 30, 35, and 40 iterations with its character intact; “target the largest lot” consolidation is predictable from a computed chain-capacity metric; and seeding a rowhouse ending is what opens the courtyard.

The grid below is a sample of the test corpus.