Procedural L-System Authoring Tool

* UPenn policy restricts public sharing of source code, so the repository isn’t included here, but the descriptions below outline my implementation and technical decisions.

What it does:

Generate procedural plants in Maya from a simple text grammar file
Control branching angle, step size, and iteration depth as node parameters
Support 3D branching in all directions (not just 2D/flat plants)
Place branch and flower geometry separately using any mesh you choose
Instance mesh regenerates automatically when base mesh changes

I developed a Maya plugin that generates procedural branching structures using an L-system grammar defined in external text files. The tool allows users to adjust iteration depth, step length, and rotation angle, and interprets the grammar to build out the corresponding geometry.

Rather than duplicating geometry, all meshes in the generated structure are instanced from user-selected base assets. This means changes to the original meshes automatically propagate throughout the entire structure, keeping the workflow lightweight and flexible for rapid visual iteration.

In addition, the plugin includes a randomized scattering module that distributes instanced geometry across user-defined spatial bounds, making it easy to populate environments efficiently while preserving editability. In the demo “city” environment, both the snow and buildings were scattered using this instancing module.

Written in Visual Studio 2022 for Autodesk Maya 2024

Languages: C++, MEL

L-System

General 3-part process:

Grammar rules encode branching structure symbolically (example below)
The turtle parses and converts that symbol string into 3D spatial data
The instancer materializes it as real geometry in Maya (gives Maya the list of branch positions/directions/scales from turtle, and the mesh you want to use)

Example:

Axiom = X

Rule = X is F[+X][-X]

Where,

F = move forward / place a segment
+ = rotate by a specified angle
- = rotate in the opposite direction
[ ] = push / pop transform state (enables branching)

Iteration 1:

Starting with axiom X
Apply rule once: F[+X][-X]
So the resulting string becomes: F[+X][-X]

Iteration 2:

Replace each X again: F[+X][-X]
Which turns into: F[+F[+X][-X]][-F[+X][-X]]