A conventional drawing might specify a window at 1.2 metres wide and 1.5 metres tall. Making it wider means redrawing the sill, frame, mullions, wall panels, and perhaps the shading around it. In a parametric model, one input controls the width while a set of rules handles the dependent geometry. Moving a slider can retain the chosen proportions while rescaling the mullions, shifting the panels, and adjusting the shading fins.

Parametric design defines geometry through parameters and the rules that connect them. When an input changes, the system recalculates. The term describes a method, not an appearance, although the architectural style known as parametricism grew from the same tools. The designer specifies the relationships that produce a shape rather than drawing only the final shape.

A short history

Antoni Gaudí explored the same principle with physical models. In the late nineteenth century, while designing the Church of Colònia Güell, he hung chains and weighted strings from a board. Gravity pulled them into catenary curves. Seen upside down, those curves described arches and vaults working in compression. Changing the length of a string, the weight of a bag of birdshot, or the position of an anchor caused the connected chains to settle into a new form. The model behaved like an analogue computer, with adjustable inputs and geometry as its output. Gaudí later developed related methods for the Sagrada Família.

Mid-twentieth-century designers continued these experiments. Frei Otto used soap films and tensile nets; Luigi Moretti worked with mathematical form-finding. Digital tools later made the approach practical at a much larger scale. In the 1990s and 2000s, Rhinoceros 3D and the visual-programming plug-in Grasshopper brought parametric modelling into everyday architectural practice. Designers could connect hundreds of operations without writing conventional code. Similar ideas appeared in Dynamo for Revit, OpenSCAD’s code-based modelling, and Python libraries such as Build123D.

Around 2008, Patrik Schumacher named the resulting aesthetic parametricism, and Zaha Hadid Architects became its most visible proponent. Buildings such as the Heydar Aliyev Center in Baku demonstrated how parameters could control continuous, fluid surfaces. The method is equally useful for less conspicuous work: optimising a roof truss, scaling a furniture component, or adjusting façade panels according to the sun’s angle.

The practice now extends well beyond architecture studios. Generative artists run parametric sketches in a browser. Product designers make one-off objects from models driven by a small set of variables. Fabricators send parametric files to CNC routers and robotic arms. Libraries such as pts.js make it possible to experiment with points, meshes, and geometric relationships without installing desktop software.

Rules instead of fixed geometry

The main difference lies in how a design is described.

Traditional thinking Parametric thinking
“This wall is 4 m long.” “This wall spans between column A and column B.”
“The window is 1.2 m wide.” “Window width = 30 % of wall width.”
“There are twenty panels on this façade.” “Panels divide the façade at 600 mm intervals.”
“The overhang is 800 mm deep.” “Overhang depth = function of solar angle at summer solstice.”
“The pattern is a fixed triangulation.” “The pattern is a Delaunay triangulation of these movable points.”

Once the rules are in place, producing another version takes little effort. Moving a point regenerates a triangulation. Changing the solar angle tilts every shading fin. Scaling a chair from child to adult size can also update the proportions of its joints. The computer handles the recalculation, leaving the designer to judge the result.

A Delaunay triangulation or Voronoi diagram provides a clear example. Place a set of points on a canvas and let the algorithm construct the triangles or cells between them. When one point moves, the mesh is rebuilt from the new set of relationships. The same logic can drive a decorative pattern, a structural space frame, or a city-block massing study.

What parameters make possible

Faster iteration is the most immediate benefit. A design that once required days of redrawing can be explored in minutes. The same model can produce a different window for each orientation of a building, or a family of products that vary in size while keeping consistent proportions.

Parametric models can also support environmental goals. If structure, material thickness, and performance criteria are represented as parameters, a designer can compare options for material use, daylight, or embodied carbon without rebuilding the model each time. It also becomes feasible to test many formal variations against the same structural or environmental constraints.

Because the underlying logic is explicit, the design is easier to share and reproduce. A Grasshopper definition or a short pts.js program can be reused with a new set of inputs, provided its assumptions are documented.

Getting started

The basic ideas can be explored without a powerful workstation or much programming experience.

  • Rhino + Grasshopper remains the most popular visual environment for architects and industrial designers. Nodes replace most of the scripting.
  • Dynamo brings the same ideas into the Autodesk / Revit world.
  • OpenSCAD and Build123D offer code-based parametric modelling suited to precise mechanical parts and 3D printing.
  • Browser-based tools such as pts.js, Paper.js, or even plain Canvas + a few math functions let you prototype relationships immediately, share them as a link, and iterate without installation.

The following conceptual pts.js sketch uses point positions as parameters:

// Minimal conceptual sketch; not runnable as written
Pts.quickStart("#pt", "#f5f5f5");

space.add({
  start: (bound) => {
    // Create random points to use as parameters
    form.points = Create.distributeRandom(bound, 12);
  },
  animate: (time, ftime) => {
    // relationships: Delaunay triangulation updates when points move
    let mesh = Create.delaunay(form.points);
    form.strokeOnly("#333", 1).mesh(mesh);
    form.fillOnly("#000").points(form.points, 4, "circle");
  },
  action: (type, px, py) => {
    // Drag a point and recompute the system
    if (type === "drag") form.points[0].to(px, py);
  }
});

Changing the number of points, constraining their movement to a curve, or driving their positions with a time-of-day slider produces a new mesh from the same rules. It is a small example, but it contains the essential parts of a parametric model: inputs, relationships, and an output that responds to both.

A system of relationships

Parametric design does not require the fluid forms associated with Zaha Hadid’s buildings. It treats a design as a system of relationships rather than a collection of fixed drawings. Gaudí’s hanging-chain models are an early physical example: change one condition and the connected parts settle into a different, coherent state.

Future articles on parametric.design will examine the tools, case studies, and small code experiments behind this way of working. The applications differ across architecture, fabrication, product design, and generative art, but the working principle remains the same: define the relationships, then study what happens when the inputs change.