Parametric Design Without Code Using Ploterr Boards

The parametric design tools architects use today — Dynamo, Grasshopper, Revit's own constraint system — are powerful. They are also built for engineers who are comfortable with code, data trees, and component scripting. Most architecture teams at the early design phase do not have that. They have a brief, a site, and a few hours to test options before a client meeting.

Ploterr Boards is parametric design built for that situation: a visual node graph where the nodes are recognisable design operations, the connections are spatial relationships, and the output is live geometry on the canvas. No scripts, no Python, no data-tree debugging. You draw the logic of a design option the same way you would sketch it on a whiteboard — as a connected diagram — and the canvas updates as you work.

What a Board is

A Board is a directed graph of nodes. Nodes take inputs, do something, and produce outputs. In Ploterr, the nodes are things architects already work with:

• View nodes — a named camera pose or floor view from your 3D canvas. The view feeds its image or geometry data downstream.
• AI Render node — takes a canvas view and returns a photoreal rendered image. Change the camera angle, the rendered result updates.
• Parametric block nodes — geometry driven by numeric inputs (height, width, storey count, floor area). Change the number, the geometry changes.
• Boolean operation nodes — union, subtract, intersect volumes. Useful for envelope studies, void analysis, coverage calculations.
• Compare node — a side-by-side before/after view of two inputs. The canonical "option A vs option B" workflow without switching between files.
• Sticky notes — documentation inside the graph, attached to the nodes they explain.

Connections between nodes are typed: an image output connects to an image input, a geometry output connects to a geometry input. If you try to connect incompatible ports, Boards flags it rather than silently producing wrong results.

Live graph evaluation

The most important property of Boards is live downstream propagation. When you change an input — adjust a slider, update a parameter, swap a view — Boards reruns every node that depends on it. You do not press "run" and wait for a batch job. The graph responds in the time it takes to evaluate, which for most early-phase operations is seconds.

This is what makes Boards a design tool rather than a scripting environment. When you are testing whether changing storey height from 3.2m to 3.6m affects the building's shadow on the neighbouring site, you drag the slider and watch both the massing and the compliance check update together. The feedback loop is immediate.

Pre-built templates

Boards ships with three templates that cover the most common early-phase workflows. You can start from a template and adapt it, or build a graph from scratch.

AI Visualization

The simplest workflow: a canvas view feeds into the AI Render node, which produces a photoreal image. The result is stored as a project artifact. Connect multiple view nodes to the same render node and you have a batch visualization pipeline — every saved camera angle gets a photoreal image without switching to a separate rendering tool.

Change the materials on a wall element in the canvas, and the next time the AI Render node runs it picks up the update. The visualization stays in sync with the model.

Parametric Design

The core parametric workflow: numeric input nodes (storey count, floor-to-floor height, core size, floor area) connect to parametric geometry blocks that build the corresponding massing or floor plan. Change a number, the geometry updates on the canvas.

This is the "live options" workflow. Instead of drawing three separate massing studies in three separate files, you have one file with one graph. The parameters define the design space, and you explore it by moving sliders and watching the canvas respond.

Boards turns design options into parameters, not files. One project, one canvas, one graph — as many options as you need to test.

Compliance Check

The most immediately practical template for early feasibility work: geometry from the canvas passes through rule check nodes that evaluate setbacks, height limits, floor area ratios, coverage percentages. Each rule node returns a pass or fail with the measured value alongside.

Connect a parametric massing block to the compliance check and adjust height — you see the pass/fail flip the moment the building crosses the height limit. No manual calculation, no re-checking a spreadsheet. The compliance result is live because the geometry it checks is live.

Early access · 25% off

Plan faster. Decide sooner.

Join the waitlist

How Boards compares to Dynamo and Grasshopper

Dynamo and Grasshopper are mature, deep parametric tools with large communities and extensive node libraries. For complex computational design, structural optimisation, or fabrication-ready geometry, they are the right tools. Ploterr Boards does not compete with that use case.

	Ploterr Boards	Dynamo / Grasshopper
Requires scripting knowledge	No	Partly — Python / C# for complex nodes
Live update without pressing 'run'	Yes	Partially — Dynamo requires manual solve
Nodes are design-native operations	Yes	no — generic data/math nodes
Connected to the BIM canvas natively	Yes	Via plugin bridge
AI render built in	Yes	No
Best phase	Concept and early design	Detailed parametric and fabrication
Free tier	Junior required	Requires Revit / Rhino licence

Boards is designed for the phase where you are still deciding, not detailing. It is fast to set up, fast to evaluate, and directly connected to the Ploterr canvas — no bridge plugins, no export-import cycle. When you finish the early design phase and move into detailed delivery, you hand the outputs forward. The Boards graph documents how you got there.

A practical example: envelope study

Say you are studying a residential block with a 15m height limit and a requirement that no point of the building casts shadow on the adjacent public park between 10am and 3pm on the winter solstice.

In Boards, you build a graph with:

1. A parametric massing block driven by height (slider), footprint area (numeric input), and building setback (numeric input)
2. A compliance check node for the 15m height limit
3. A second compliance check node for a shadow cone calculation (your own rule definition)
4. A Compare node showing the massing at 12m vs 15m side by side
5. An AI Render node producing a street-level photoreal view of each option

You drag the height slider. The massing, both compliance checks, the comparison, and the photoreal render all update. You find the maximum height that passes both rules in the same session you set the graph up.

That is the full early-design workflow: constraint definition, option generation, compliance validation, and client-ready visualization — in one canvas, one Board, one session.

Getting started

Boards is available on Ploterr Junior. Open any project, navigate to the Boards tab, and either start from a template or build from scratch. Nodes are dragged from the sidebar; connections are drawn by clicking and dragging between ports. The 3D canvas updates in real time as you build and run the graph.

Join the waitlist and get 25 percent off. The Core tier is free forever for up to 10 projects; Junior ($69/user/month) unlocks Boards and unlimited AI generations.

Early access · 25% off

Plan faster. Decide sooner.

Join the waitlist