Studio Matrx Monthly · Volume 1 · Issue 4 · September 2026
Amogh N P
 In loving memory of Amogh N P — Architect · Designer · Visionary 
Procedural City GenerationLesson 3.2
Generative & Parametric Urbanism/Module 3 · Generative Urban Design

Lesson 3.2 · Generative Urban Design

Procedural City Generation

Rules can grow street networks, subdivide blocks into plots and place buildings by shape grammar, filling a whole urban fabric automatically - a genuinely useful way to explore structure and texture, born in games and film where a city only has to LOOK convincing, and carrying that origin's honest limit into a real city that must actually be just, buildable, owned and lived in

12 min Interactive lessonFree · open lessonByAmogh N P· Architect & interior designer
The hook

A few rules can grow a whole city that no one drew - which is exactly why you must ask what those rules never knew.

Open a modern open-world video game and you can drive through a sprawling city no one drew - the streets, the blocks, the endless facades were grown by a program, on the fly, from a handful of rules. The same trick fills film backdrops with skylines that never existed and stadiums with crowds no one animated by hand. This is procedural generation: writing rules that produce complex form automatically, so that a few lines of logic bloom into a whole apparent world. It is one of the oldest and most concrete forms of generative design, and it maps seductively onto cities - grow the roads, carve the blocks, drop in the buildings, and out comes an urban fabric.

It is genuinely useful, and this lesson takes it seriously: procedural methods can grow street networks, subdivide blocks into plots, and apply shape grammars to place buildings, giving urbanists a fast way to test structure and fill in a masterplan's texture. But it also carries an honest and important limit that the field must never forget. The technique was born where a city only has to *look* like a city - on a screen, for a player who will never live there. A real city has to *be* a city: just, buildable, financeable, owned, contested, and above all inhabited, including the vast informal and organic fabric no tidy rule ever generated. Learn the methods; refuse the assumption that a convincing surface is a sufficient plan.

Grow the network (L-system / agents) -> carve blocks -> subdivide plots -> place buildings (shape grammar). A few rules -> a whole plausible city. But it grew up in GAMES/FILM (looks like a city). Real city must BE one. Plausible != good.

Growing street networks by rule - L-systems and agents

Procedural generation means producing complex form automatically from rules rather than placing every element by hand. In urbanism its most vivid application is growing a street network. Two families of method dominate. The first borrows the L-system, a rule-rewriting idea invented to model how plants branch: you start from a seed and a small grammar - 'extend a road forward; every so often, branch left and right; stop at water or a steep slope' - and apply the rules over and over, so that from a single origin a whole branching network of primary and secondary streets unfolds, step by step. The second family is agent-based: you release simple agents that follow local rules - head toward the nearest unserved area, avoid crossing another road at a shallow angle, connect to the closest junction - and the network emerges from their collective behaviour, much as a real city's lanes emerged from countless individual builders.

What makes these powerful is that a few rules produce a great deal of coherent, plausible structure very fast, and the rules can respond to inputs: feed in a terrain model, a population-density surface or arterial constraints, and the growing network bends around hills, thickens where density is high and ties into the roads that already exist. You can generate a candidate road structure for a large new area in seconds, then vary the rules and generate another, exploring structural options at a speed no drafting could match. For understanding how street patterns *could* run, and for seeding a masterplan's skeleton, this is a real tool.

And here the honesty begins. A grown network *looks* like a city because it copies the geometry of one - but the rules know nothing of what a street is *for*. They do not know that this lane is the route a funeral takes, that that junction is where the neighbourhood gathers, that this alignment would sever a settlement from the well it depends on. The method reproduces the *pattern* of streets while being blind to their *meaning*, their ownership, and the lives organised around them. So a procedural network is a fine way to generate and test structural options to think with - and a dangerous thing to mistake for a plan, because the very ease with which it produces convincing geometry hides how much of the real street - the human, legal and social street - it never touched.

GROWING A STREET NETWORK BY RULEL-system / agent-based: start from a seed, apply local rules, the network emerges step by stepstep 1: seed + extendstep 2: branch rule splitsstep N: an emergent networklooks like a city - but the rules know nothing of who lives, works or belongs here
Zoom
Growing a street network by rule. From a seed, an L-system or agent-based method applies simple local rules - extend, branch, avoid, connect - over and over, so a whole network of primary and secondary streets unfolds step by step, bending around terrain and thickening where density is high. A few rules produce a great deal of plausible structure, very fast. But the rules reproduce only the geometry of a street: they know nothing of what it is for, who lives along it, or the ownership and life organised around it.

L-system (seed + branch rules) and agent-based methods GROW a street network step by step. A few rules -> lots of plausible structure, fast. But the rules know the geometry of a street, never its meaning, ownership or life.

Blocks, plots and shape grammars

Once you have a street network, procedural methods carry on down the hierarchy of urban form. The streets enclose blocks, and each block can be automatically subdivided into plots, and each plot given a building - so the whole fabric, from arterial to front door, can be generated by rule. Block subdivision is often handled by simple recursive geometry: split the block along its longest axis, keep splitting until each piece is roughly the target plot size, ensure each plot touches a street. More sophisticated versions use a shape grammar - a formal set of rules that rewrite shapes into more detailed shapes, so a block becomes plots, a plot becomes a footprint-and-yard, a footprint becomes massed floors with setbacks and a roof. Shape grammars have a serious pedigree in architecture; famously they were used to capture the 'rules' behind historical styles, generating new designs in the manner of a known vocabulary.

Applied to urban fabric, this is genuinely handy. From a few parameters - target plot width, coverage, height, setback - a generator can populate an entire district with plausible, varied buildings, giving a masterplan texture and letting you preview density, grain and street-wall continuity at scale. Change the grammar and the whole character shifts: fine-grained shophouse plots or coarse superblocks, continuous street walls or free-standing towers. As a way to explore and visualise the *consequence* of plot and massing rules across a large area, procedural subdivision earns its place.

But a plot is not a rectangle. In the real city a plot is a bundle of ownership, history, tenure, dispute and livelihood - who holds title, who has occupied it for generations without title, what the family shop on its ground floor supports, which cases are pending in court. A generative subdivision that carves a district into neat parcels can quietly assume all of that away, drawing over existing owners and occupants as if the ground were blank. This is not a hypothetical worry in India, where land records are complex and contested and where a great deal of the city is held and built informally: a shape grammar sees none of it. So use procedural subdivision to study grain and massing options - and never let its tidy parcels stand in for the messy, legal, human reality of who owns and inhabits the ground, which no grammar can generate and which the statutory land and planning process alone can settle.

NETWORK -> BLOCKS -> PLOTS -> BUILDINGS1. streets enclose blocks2. grammar splits into plots3. rules place buildingstidy and fast - but real plots carry ownership, history, informality and dispute the grammar cannot see
Zoom
From network to blocks to plots to buildings. Once streets enclose blocks, recursive subdivision or a shape grammar splits each block into plots, and further rules place buildings with setbacks and heights - so a whole district's grain, density and massing can be generated from a handful of parameters. This is genuinely useful for studying and previewing form. Yet a plot is not a rectangle: it is ownership, tenure, history, livelihood and dispute the grammar cannot see, which in the Indian context of complex land records and informal building is the substance, not a detail.

Roots in games and film - and the honest limit

It matters where these methods came from, because their origin shaped their assumptions. Procedural city generation matured largely in games and film, where the goal is a city that *looks* convincing: vast, varied, cheap to produce, generated on the fly so a player can roam or a camera can fly through. In that world procedural generation is a triumph - it delivers endless plausible urban texture that no team could model by hand, and no one is harmed if a generated street leads nowhere sensible or a district makes no economic sense, because no one lives there. The entire success criterion is the *plausible surface*.

That inheritance is the honest limit you must carry into real urbanism. A real city is judged by a completely different standard. It has to be just - to serve the people who live there and not price them out. It has to be buildable and financeable - to stand up, to connect to infrastructure, to make sense economically. It has to respect ownership and law, to carry livelihoods, and above all it has to be lived in - people spend their lives inside the result. And it has to make room for the informal and organic fabric that no clean generator produces and that houses, in Indian cities, a very large share of the population. Against that standard, the games-and-film criterion - does it look like a city? - is nowhere near enough. Plausibility is not goodness. A procedurally generated district can be entirely convincing to the eye and completely wrong as a place to live: dead at street level, blind to who is already there, optimized for a fly-through rather than a life.

The disciplined position is to borrow the *technique* while refusing the *assumption*. Procedural generation is a powerful, legitimate way to generate structural and textural options for urban form - to grow candidate networks, test grain, and fill a masterplan with previewable fabric to reason about. But its origin in worlds where a convincing appearance is the whole point leaves a residue that must be consciously stripped out: the quiet belief that if the result looks like a city, the design work is done. In real urbanism that is exactly where the design work begins - with everything the generator could not see, and with the binding decisions that stay human, democratic and legal.

ROOTS IN GAMES + FILM - AND THE HONEST LIMITGAMES / FILM: looks-like a city- needs to LOOK convincing on screen- endless variety, generated fast- no one lives or dies by the plan- plausible surface is the whole goala triumph - for its purposeA REAL CITY: must BE a city- must be just, buildable, financeable- carries ownership, law, livelihoods- must include the informal + organic- people actually live inside the resultplausible is not the same as goodborrow the technique; never inherit the assumption that a convincing surface is a sufficient plan
Zoom
The honest limit, and where it comes from. Procedural city generation matured in games and film, where a city only has to LOOK convincing to a player or camera who will never live there - and for that purpose it is a triumph. A real city is judged by a far harder standard: it must be just, buildable, financeable, respectful of ownership and law, carry livelihoods, be genuinely lived in, and include the informal and organic fabric no clean generator produces. Plausible is not the same as good. Borrow the technique; refuse the inherited assumption that a convincing surface is a sufficient plan.

Procedural generation grew up in games/film, where a city only has to LOOK like a city. A real city must BE one - just, buildable, owned, lived-in, including the informal. Borrow the technique; refuse the assumption that a plausible surface is a plan.

Using it honestly - explore and show, do not decide

So how should an urbanist actually use procedural generation, honestly? Treat it as an instrument for exploration and communication, not a decision engine. It is genuinely good at a few things. It can rapidly generate structural options - many candidate street networks and block layouts for a large area - so a team can reason about connectivity, grain and density across possibilities instead of defending one sketch. It can fill in texture so that a masterplan is legible - stakeholders see a plausible three-dimensional district rather than an abstract zoning diagram, which genuinely helps a public conversation. And it can stress-test rules: change the subdivision or massing grammar and watch the whole fabric respond, revealing what your plot and height policies would really produce at scale. Used this way, procedural methods extend the studio's reach and make consequences visible.

The failures to guard against are equally clear. Do not mistake the plausible surface for a resolved plan - the generator produced geometry, not justice, buildability or belonging. Do not let the grammar's tidy parcels erase the real ground - the ownership, tenure, informality and livelihoods it cannot see, which in the Indian context are enormous and legally weighty. Do not let generated fabric quietly standardise a place, imposing one grammar's grain over the fine-grained mixture that makes a real district live. And never present a procedurally generated district as objective or inevitable; it is one output of the rules someone chose.

The boundary is firm and familiar. Procedural generation helps you *explore and show* what urban form could be; it does not decide what it should be. The actual planning and land-use decisions, the statutory approvals, and the social, equity and political judgements - who owns the ground, who is displaced, what a community wants, what the law requires - belong to the planning authority, the democratic and participatory process, the affected communities, and the governing planning law and development-control regulations, in India the master-plan and development-plan process, the applicable DCR and the National Building Code of India. Grow candidate cities to think with; keep the real city a human, legal and democratic act.

Verify-this: grow candidate form by rule; keep the real, owned, lived-in city a human and legal act

Growing networks by rule

L-systems and agents

Street networks can be grown from a seed by branching rules (L-systems) or by simple local-rule agents. Fast, plausible structure - but the rules reproduce a street's geometry, never its meaning, ownership or life. Modules 3.2, 4.1.

Subdivision and shape grammars

Blocks, plots, buildings

Recursive subdivision and shape grammars carve blocks into plots and place buildings from a few parameters - useful for studying grain and massing, but a plot is ownership, tenure and livelihood the grammar cannot see. Modules 3.2, 4.2.

Plausible is not good

The games/film inheritance

Procedural generation matured where a city only has to LOOK convincing. A real city must actually be just, buildable, owned and lived-in. Borrow the technique; refuse the assumption that a convincing surface is a plan. Modules 3.2, 3.3, 9.1.

The ground is not blank

Land, tenure, informality

Generated parcels can erase existing owners, untitled occupants and the informal city - acute in India. Real land, tenure and displacement questions belong to the statutory land and planning process, not a grammar. Modules 3.2, 7.3, 10.3.

Hands-on workshop

Workshop - grow a network by rule, then find what it cannot see

Procedural generation is easiest to understand by doing it by hand for a few steps, then honestly auditing the result. You will grow a small street network from a written rule, subdivide a block, and then walk a real place to list everything your rules could never have known.

Just graph paper and a place you know. No software - growing a network by hand makes both the power and the blindness vivid; real procedural tools and land data come later, and the binding land, planning and equity decisions always stay with the statutory process, the community and the law.

Given & goal
Goal: feel both the power and the blindness of rule-grown urban form
Inputs: graph paper or a notebook, and a real neighbourhood you can picture or visit
Time: ~50 minutes
  1. 1Write a tiny grammar: 3-4 rules for growing a street network (for example: extend the main road 3 squares; every 3 squares branch a side road left and right; stop at the river edge). Write them before you draw anything.
  2. 2Grow it by hand: apply the rules step by step for 6-8 iterations, drawing exactly what the rules dictate - not what looks nice. Then pick one block and subdivide it into plots by a simple rule (split the longest side until plots are about equal).
  3. 3Admire the plausibility: note how quickly a convincing-looking piece of city appeared from a few rules. This is the real power.
  4. 4Audit the blindness: now list 8-10 things about a REAL version of this place that your rules never knew - who owns each plot, which shop feeds a family, where people actually gather, the shrine, the informal homes, the disputed corner. Mark which are legal, which are economic, which are social.
  5. 5Reflect as reasoning: write a paragraph on what procedural generation genuinely gave you (structure, speed, options to think with), what it was blind to (the owned, lived-in, informal city), and why the binding decisions about this ground must stay human, legal and democratic - flagged as reasoning.

You’ll walk away with
A one-page artefact: your written grammar, the hand-grown network and subdivided block, and an honest audit of everything the rules could not see, ending in a reasoning paragraph on procedural generation's real role. Keep it - later modules put real network and land analysis behind this by-hand version.

The worked example

Three altitudes on the same idea

Read the band that fits you — or all three.

For the architect / urban designerUsing computation to explore, analyse and test urban form - while people and the democratic process decide

For the architect or urban designer, procedural generation is a fast, concrete way to grow structural and textural options - candidate street networks, block subdivisions, massing across a whole district - and reason about grain, connectivity and density instead of defending one sketch. It is excellent for exploration and for making a masterplan legible to a public that reads a plausible three-dimensional district far better than an abstract diagram. But carry its origin consciously: the method matured where a city only has to look convincing, so it is expert at the plausible surface and blind to everything beneath it - what a street is for, who owns a plot, whether the result is just, buildable or lived-in. Never let generated geometry stand in for a resolved plan, never let a shape grammar's tidy parcels erase real ownership, tenure and informality, and never present generated fabric as objective. Use it to think and to show; defer the binding land, planning and equity decisions to the planning authority, the community and the law.

For the planner / urbanistWhere computational methods genuinely help planning and where the city's human and political life resists them

For the planner or urbanist, procedural generation can accelerate scenario-building and public visualisation - but it is most dangerous exactly on the ground you are responsible for: land, tenure and the informal city. A generator that carves a district into neat parcels and drops in buildings can quietly assume away existing owners, long-term occupants without title, and the livelihoods and disputes attached to every plot - which, in Indian cities with complex land records and vast informal fabric, is not a detail but the substance. And a plausible generated district can read as settled and objective to decision-makers and the public when it is nothing of the kind. Use procedural methods to open up and illustrate options for genuine deliberation, insist that the real land and tenure reality is established through the statutory process rather than assumed by a grammar, and keep the binding decisions with the affected communities, the planning authority and the law. Plausible is not the same as agreed, or just.

For the studentHow cities can be grown by rule - and why a city is a living system, not an optimization problem

Procedural city generation is one of the most tangible ideas in the whole course, and a great one to be able to explain. The core: instead of drawing a city, you write rules that grow it - L-systems and agent-based methods extend and branch a street network step by step; recursive subdivision and shape grammars split blocks into plots and place buildings - so a few parameters bloom into a whole fabric. It is powerful for exploring structure and texture fast. The critical point to grasp is where it came from: games and film, where a city only has to LOOK convincing to a player or camera who will never live there. A real city has to BE a city - just, buildable, owned, financeable, lived-in, and inclusive of the informal and organic fabric no clean generator produces. So the honest lesson is 'plausible is not good': a procedurally generated district can look completely convincing and be entirely wrong as a place to live. Learn to borrow the technique while refusing that inherited assumption - and you will understand generative urbanism far more deeply than someone who only sees the pretty output.

Misconception check

If we can procedurally generate entire convincing cities in video games - streets, blocks, thousands of buildings - then we can basically generate real masterplans the same way. The technology already exists; real urban planning just needs to adopt the game engines.

This mistakes a resemblance for an equivalence, and it is the central error the lesson guards against. Procedural generation is genuinely powerful and does map onto urban form - it can grow street networks with L-systems or agents, subdivide blocks into plots, and place buildings with shape grammars, all fast and at scale. But it matured in games and film, where the entire success criterion is that the city LOOKS convincing to a player or a camera. No one lives in a generated game city; no one is priced out of it, displaced by it, or harmed if its economics make no sense. A real city is judged by a completely different and far harder standard: it must be just, buildable, financeable, respectful of ownership and law, carry real livelihoods, be genuinely inhabited, and make room for the informal and organic fabric that no clean generator produces and that houses a huge share of people in Indian cities. Against that standard the generated surface is only the surface. A procedurally generated district can be entirely plausible to the eye and completely wrong as a place to live - dead at street level, blind to who already occupies the ground, its tidy parcels drawn straight over real owners, tenants and disputes. Plausible is not good. So the honest use is to borrow the technique - to explore structural options, test grain and massing rules, and make a plan legible for public discussion - while refusing the inherited assumption that a convincing appearance is a sufficient plan. The real design work is everything beneath the surface the generator cannot see, and the binding decisions about land, displacement and a community's future stay human, democratic and legal.
Try it

Do it yourself

No software needed - reason it through.

  1. 1Describe two ways to grow a street network by rule (L-systems and agent-based) and what each does.
  2. 2Explain how blocks are subdivided into plots and how shape grammars place buildings - and why this is useful for studying grain and massing.
  3. 3A shape grammar carves a district into neat plots. Name three real things about those plots it cannot see - and why they matter in the Indian context.
  4. 4Procedural generation came from games and film. Why does that origin leave an 'honest limit', and what does 'plausible is not good' mean?
  5. 5How should an urbanist use procedural generation, and where must the binding decisions stay?
Take this with you

The one line to carry out

Procedural generation can grow a whole urban fabric by rule - street networks from L-systems and agents, blocks subdivided into plots, buildings placed by shape grammar - which is genuinely useful for exploring structure and texture fast, but it matured in games and film where a city only has to LOOK convincing, so it is expert at the plausible surface and blind to everything beneath it: what a street is for, who owns a plot, whether the result is just, buildable, lived-in and inclusive of the informal city - so borrow the technique, refuse the assumption that a convincing surface is a plan, and keep the binding, owned, human city a democratic and legal act.
Take it further
References & further reading

Peer-reviewed journals & authoritative standards

  1. 01Procedural generationWikipedia - Procedural generation, 2026.
  2. 02L-systemWikipedia - L-system, 2026.
  3. 03Shape grammarWikipedia - Shape grammar, 2026.
  4. 04Agent-based modelWikipedia - Agent-based model, 2026.
  5. 05Cellular automatonWikipedia - Cellular automaton, 2026.
Related lessons
Recap
Procedural generation produces complex form automatically from rules rather than by hand, and it maps concretely onto cities. Street networks can be grown from a seed by branching rules (the L-system idea, borrowed from modelling how plants branch) or by agent-based methods where simple local rules produce an emergent network - both giving a lot of plausible structure from a few rules, very fast, and able to respond to terrain, density and existing roads. From the network, recursive subdivision and shape grammars carve blocks into plots and place buildings from a few parameters, letting you populate and preview a whole district's grain, density and massing. This is a genuine tool for exploring structural and textural options and making a masterplan legible. But its origin is the key to its limit: procedural city generation matured in games and film, where the whole success criterion is that the city LOOKS convincing to a player or camera who will never live there - so it is superb at the plausible surface and blind to what lies beneath. A real city is judged far harder: it must be just, buildable, financeable, respectful of ownership and law, carry livelihoods, be genuinely lived in, and include the informal and organic fabric no clean generator produces and that houses a huge share of people in Indian cities. Plausible is not good: a generated district can look entirely convincing and be wrong as a place to live, its tidy parcels drawn over real owners, tenants and disputes the grammar cannot see. So the discipline is to borrow the technique - grow candidate networks, test grain, make plans legible for public discussion - while refusing the inherited assumption that a convincing appearance is a resolved plan. The real design work, and the binding decisions about land, displacement and a community's future, stay human, democratic and legal.
Carry forward →

Procedural rules are one way an algorithm proposes form. The newest and most powerful - and most dangerous - is AI: generative models that learn from precedent to produce plausible urban fabric. Next we examine what AI adds to generative urbanism, and the specific risks of plausible-but-wrong output and bias in the training data.

A

The author

Amogh N P

Architect, interior designer, and creative polymath. Studio Matrx began in his notebooks — his vision of design made honest, useful, and open to everyone. Its Academy is written and taught in his memory, and free, forever.

More about Amogh →