Family Parameters — Create parameters and label dimensions (parametric behavior) - Autodesk Revit

SECTION 1

Historical Context & Motivation

Before Building Information Modeling (BIM) software existed, architects and designers drew every variation of a door, window, or furniture piece as a separate, static block in CAD. If a client asked for a wider door frame, you redrew the geometry from scratch. This workflow was not only tedious but also error-prone—dimensions could fall out of sync, schedules wouldn't update, and design iteration ground to a halt. The fundamental problem was that traditional CAD elements had no embedded intelligence: a rectangle representing a countertop was just lines on a screen, carrying no knowledge of its material, cost, or relationship to adjacent objects.

The concept of parametric design emerged as the antidote: geometry driven by variables, so that changing one number ripples predictably through the entire model. Autodesk Revit, first released in 2000, was built from the ground up around this idea. Its Family Editor became the workshop where designers define parameters—named variables—and bind them to dimensions, materials, and visibility states, transforming inert shapes into intelligent, reusable components.

1982 • AutoCAD Launches

Autodesk releases AutoCAD, introducing 2D computer-aided drafting. Elements are static lines and arcs with no embedded data—every design change requires manual redrawing.

1988 • Pro/ENGINEER Introduces Parametric Modeling

PTC's Pro/ENGINEER brings parametric, feature-based solid modeling to mechanical engineering, proving that geometry can be driven by named dimensions and constraint relationships.

2000 • Revit 1.0 Released

Charles River Software (later acquired by Autodesk) ships Revit, the first purpose-built BIM platform where every element is a parametric family instance carrying both geometry and data.

2002 • Autodesk Acquires Revit

Autodesk acquires Revit Technology Corporation and begins expanding the Family Editor, adding shared parameters, type catalogs, and nested family capabilities that empower designers to build sophisticated parametric components.

2010–Present • Parametric Families Become Industry Standard

Revit families with labeled dimensions and formula-driven parameters become the backbone of BIM workflows worldwide, enabling automated schedules, clash detection, and design-option studies.

The central question this lesson addresses is deceptively simple: How do you make a Revit family that intelligently changes its geometry when a user types in a new number? The answer lies in creating parameters, labeling dimensions with those parameters, and understanding the constraint logic that governs parametric behavior.

SECTION 2

Core Principles & Definitions

Parametric behavior in Revit families rests on a handful of foundational ideas. Understanding these principles before opening the Family Editor will save you hours of frustration and produce families that are robust, flexible, and easy for collaborators to use. At its heart, a parameter is a named variable that stores a value—a length, a material, an on/off toggle—and a labeled dimension is the bridge that connects that variable to the actual geometry of your family. Without the label, the dimension is just a static measurement; with it, the dimension becomes a lever the user can pull.

Parameters as Named Variables

A parameter is a container with a name (e.g., "Width"), a data type (Length, Material, Yes/No), and a value. When a user places a family instance, they interact with parameters through the Properties panel or Type Properties dialog.

Labeling Dimensions

Placing a dimension string between two reference planes and then assigning a parameter name to it creates a live link. Revit's constraint solver ensures the distance between those planes always equals the parameter's current value.

Type vs. Instance Parameters

Type parameters are shared by every instance of a given type (e.g., all 900 mm doors). Instance parameters can differ per placement (e.g., a sill height that varies by window). Choosing correctly prevents downstream chaos.

Reference Planes as the Skeleton

Geometry in a Revit family should be constrained (locked) to reference planes, not to other geometry. Parameters drive the spacing of these planes, and the geometry follows. This decoupling makes the family predictable and stable.

The Flexing Test

After labeling dimensions, you change parameter values and observe whether the geometry updates correctly without errors. This 'flex test' is the essential quality-assurance step that validates parametric behavior before the family is loaded into a project.

✦

KEY TAKEAWAY

Think of reference planes as the bones of a puppet, parameters as the strings attached to those bones, and labeled dimensions as the knots that tie each string to its bone. When you pull a string (change a parameter value), the bone moves, and the puppet's fabric (geometry) follows. Without the knot (the label), pulling the string does nothing—the puppet stays frozen.

SECTION 3

Visual Explanation — The Parametric Chain

The diagram below illustrates the complete parametric chain inside a Revit family—from the user-facing parameter value all the way to the on-screen geometry update. Understanding this flow is essential because every debugging session you'll ever have traces back to a broken link in this chain.

The parametric chain: a parameter stores a value, a label binds it to a dimension between reference planes, and the geometry locked to those planes updates accordingly.

Notice the strict hierarchy in the diagram. Geometry is never driven directly by the parameter—it is always mediated through reference planes and dimensions. This indirection is intentional: it allows Revit's constraint solver to evaluate all relationships simultaneously, much like a system of linear equations being solved in one pass. If you lock an extrusion's edge directly to a dimension without an intermediary reference plane, the family may appear to work at first, but it will become fragile and produce errors when multiple parameters interact.

SECTION 4

How It Works — The Parametric Mechanism

While family parameters don't involve calculus, they do rely on a logical mechanism that can be expressed in quasi-mathematical terms. Understanding this mechanism clarifies why certain family configurations succeed and others fail. At its core, Revit's parametric engine operates on a system of geometric constraints—equations that relate the positions of reference planes to parameter values.

DIMENSION CONSTRAINT

d(Plane_A, Plane_B) = P

Where d is the measured distance between Plane A and Plane B, and P is the value of the labeled parameter. When the user sets P = 1200 mm, Revit repositions Plane B so that d = 1200 mm.

FORMULA-DRIVEN PARAMETER

Half_Width = Width / 2

Revit allows parameters to be defined by formulas referencing other parameters. Here, Half_Width always equals half the value of Width. This is useful for centering geometry on an origin plane.

CONDITIONAL FORMULA

Trim_Width = if(Has_Trim, 50 mm, 0 mm)

Conditional (if/then) formulas allow a Yes/No parameter (Has_Trim) to control a length parameter. When Has_Trim is checked, Trim_Width becomes 50 mm; when unchecked, it collapses to zero.

The constraint solver evaluates all these equations simultaneously each time a parameter value changes. If it encounters a circular dependency—where Parameter A depends on Parameter B which depends on A—Revit will flag an error and refuse the formula. Similarly, if a parameter change would cause geometry to invert or collapse to negative dimensions, the solver will report a constraint failure. These guardrails are what make parametric families reliable: the system fails loudly rather than producing corrupt geometry.

💡

Formula Syntax in Revit

Revit uses its own formula syntax, not Excel formulas. Key operators include: +, -, *, / for arithmetic, if(condition, then, else) for conditionals, and functions like sqrt(), sin(), cos() for trigonometry. Length parameters must include unit suffixes (e.g., 50 mm) within formulas.

SECTION 5

Detailed Breakdown — Parameter Types & Data Categories

Not all parameters are created equal. Revit distinguishes parameters along two independent axes: scope (who can see and edit the parameter) and data type (what kind of value it stores). Making the right choice at creation time is critical because changing a parameter's scope later often requires deleting and recreating it, which breaks labeled dimensions.

The matrix shows how Family, Shared, and Global parameters can each store various data types. Within Family and Shared scopes, each parameter is additionally classified as Type or Instance.

Parameter Scope	Created Where	Schedulable?	Best For
Family	Inside the Family Editor	No (not visible in schedules)	Internal geometry control, helper calculations
Shared	Shared Parameter File (.txt), then loaded into family	Yes — appears in schedules & tags	Data that must be reported: cost, fire rating, finish color
Global	Inside the project (Manage tab)	N/A — drives dimensions in the project	Project-wide standards (corridor width, default ceiling height)

Parameter scope comparison

For most visual-arts and design applications—furniture pieces, light fixtures, display cases—you will primarily use Family parameters to drive geometry and Shared parameters when you need the data to appear in a schedule or tag. A common beginner mistake is using only Family parameters and then discovering that those values cannot be extracted into a schedule—forcing you to recreate parameters as Shared, which means relabeling every affected dimension.

SECTION 6

Worked Example — Building a Parametric Picture Frame Family

Let's walk through the creation of a parametric picture frame family from scratch. This example is deliberately art-world relevant: a gallery picture frame that can adapt to any canvas size, with toggleable trim and a controllable frame depth. By the end, you'll have a family with five parameters and four labeled dimensions.

Parametric Picture Frame — Step by Step

1
Step 1 — Start a New Family

Open Revit and choose File → New → Family. Select the Generic Model face based.rft template (ideal for objects mounted on walls). You'll see a plan view with two default reference planes forming a crosshair at the origin.

Family Editor opens with origin reference planes visible.
2
Step 2 — Draw Reference Planes for Width and Height

In the plan view, draw two vertical reference planes symmetrically about the center vertical axis—these will define the left and right edges of the frame. Then switch to a front elevation and draw two horizontal reference planes symmetrically about the center horizontal axis for top and bottom edges. You now have a rectangular 'cage' of four reference planes (plus the two origin planes) that defines the frame's footprint.

Four new reference planes added: Left, Right, Top, Bottom.
3
Step 3 — Place Dimensions and Create Parameters

Select the Annotate → Aligned Dimension tool. Click the Left reference plane, then the Right reference plane, then place the dimension string. With the dimension selected, look at the Options Bar (or the label dropdown near the dimension text). Click '<Add parameter…>'. In the Parameter Properties dialog, enter Name: Frame_Width, set Type/Instance to Type, Group under Dimensions, and confirm. Repeat for the vertical dimension between Top and Bottom planes, naming it Frame_Height. You have just labeled two dimensions.

Frame_Width and Frame_Height parameters created and labeled to their respective dimensions.
4
Step 4 — Draw Geometry and Lock to Reference Planes

Use Create → Extrusion. Draw a rectangular profile whose edges align with the four reference planes. Critically, lock each edge to its nearest reference plane by clicking the padlock icon that appears when you align (use the Align tool, shortcut AL). Then create a second, smaller extrusion for the inner void (the canvas opening), offset inward by a Border_Width parameter. Set the extrusion depth via a parameter called Frame_Depth. Use a void extrusion cut to carve out the canvas area.

Extrusion geometry locked to reference planes; Border_Width and Frame_Depth parameters created.
5
Step 5 — Add a Yes/No Parameter for Trim Visibility

Model a small decorative trim extrusion around the inner edge. In the Family Types dialog (shortcut FT), create a new parameter: Name = Has_Trim, Type = Yes/No, Instance parameter. Select the trim geometry, and in Properties, associate its 'Visible' parameter with Has_Trim by clicking the small button to the right of the Visible checkbox. Now the trim appears only when Has_Trim is checked.

Has_Trim (Yes/No) parameter controls trim visibility per instance.
6
Step 6 — Flex Test the Family

Open Family Types (FT). Change Frame_Width from 600 mm to 400 mm and click Apply. The frame should narrow symmetrically. Change Frame_Height to 800 mm—it should grow taller. Toggle Has_Trim on and off. Set Border_Width to 30 mm and then 80 mm. If any change causes an error or geometry that doesn't move as expected, trace the issue back through the parametric chain: is the dimension labeled? Is the geometry locked to the reference plane? Is the reference plane constrained by the dimension?

Family flexes correctly across all parameter combinations — ready to load into project.

💡

Pro Tip for Visual Arts Students

When building gallery or exhibition families, make canvas dimensions Type parameters (so all frames of one type match) but make wall-offset or hanging height Instance parameters (so each placement can be fine-tuned for a specific wall). This mirrors the real-world logic: you order frames in standard sizes but hang them at different heights.

SECTION 7

Strengths, Limitations & Common Pitfalls

Parametric families are extraordinarily powerful, but they are not without constraints and common failure modes. A clear-eyed assessment of strengths and limitations will help you design families that are robust in practice, not just in controlled demonstrations.

Strengths	Limitations / Pitfalls
One family file serves dozens of size variations, reducing file management overhead and ensuring visual consistency.	Over-parameterizing a family (too many variables) makes it fragile—small value changes can cause cascading constraint failures.
Schedules automatically reflect parameter values, keeping documentation synchronized with the 3D model.	Family parameters cannot be scheduled or tagged; you must use Shared parameters for reporting, adding an extra setup step.
Formulas enable complex relationships: proportional scaling, conditional visibility, and trigonometric positioning.	Revit's formula engine is limited—no looping, no array parameters, no string manipulation. Complex logic may require Dynamo or API scripting.
Type Catalogs allow hundreds of predefined sizes to load from a single .rfa file, streamlining content libraries.	Geometry that isn't properly locked to reference planes will not move when parameters change—the most common beginner error.
Nested families allow modular design: swap sub-components (handles, legs, panels) via a Family Type parameter.	Nested families add complexity; each nesting level must pass parameters down explicitly, or the inner family ignores the outer family's changes.

Parametric Family Strengths vs. Limitations

✦

KEY TAKEAWAY

Think of a parametric family like a well-designed exhibit display system—modular, adjustable, and reusable across venues. But just as over-engineering a display mount with too many adjustment joints can make it wobbly and prone to failure, over-parameterizing a family introduces fragility. The best families have the fewest parameters needed to achieve the required flexibility, with every constraint deliberate and tested.

SECTION 8

Connection to Advanced Parametric Workflows

The parameter-and-label workflow you've learned here is the foundation, but Revit's parametric capabilities extend well beyond simple dimension-driving. Once you're comfortable with the basics, several advanced topics build directly on these concepts and are especially relevant for visual-arts applications involving complex or organic forms.

This Lesson (Fundamentals)	Advanced Extension
Manually create parameters in the Family Editor and label individual dimensions.	Dynamo / Computational Design: Use visual programming to generate hundreds of parameter values algorithmically—e.g., creating an array of fins whose angle varies according to a sine function.
Simple formulas (arithmetic, if/then) to relate parameters within one family.	Adaptive Components: Families with flexible placement points that deform geometry based on the positions of those points—used for curtain-panel patterns, parametric facades, and sculptural installations.
Yes/No parameters toggling visibility of sub-elements.	Nested Families with Family Type Parameters: A 'Family Type' parameter lets users swap entire sub-components (e.g., different lamp shades within a light fixture family), enabling a kit-of-parts design philosophy.
Shared parameters for scheduling.	Revit API / Macros: Programmatic creation and modification of parameters via C# or Python, enabling batch processing, data import from spreadsheets, and integration with fabrication pipelines.

From fundamentals to advanced parametric workflows

For visual-arts students in particular, the bridge to Dynamo is perhaps the most exciting next step. Dynamo is a visual-scripting environment that ships with Revit and lets you create complex, algorithmically-driven parameter assignments without writing traditional code. Imagine generating a gallery wall of picture frames where each frame's dimensions follow a Fibonacci sequence, or creating a parametric ceiling installation where panel angles respond to a mathematical attractor point—all driven by the same parameter-labeling logic introduced in this lesson, but automated at scale.

SECTION 9

Practice Problems

Question 1: CONCEPTUAL

Explain, in your own words, why geometry in a Revit family should be locked to reference planes rather than dimensioned directly between two pieces of geometry. What problem does this intermediary step solve?

Show answer

Reference planes serve as a stable skeletal framework that Revit's constraint solver can manipulate without ambiguity. When you dimension directly between geometry edges, the solver must decide which edge to move—and in complex families, this decision becomes unpredictable. By routing all parametric changes through reference planes, you create a clear hierarchy: parameters drive plane positions, and geometry follows planes via locks. This decoupling also means you can reposition or replace geometry without losing parametric behavior, and it prevents circular dependencies where one geometric element's position depends on another's, which in turn depends on the first.

Question 2: BASIC CALCULATION

You have a parametric shelf family with a Type parameter Total_Width = 1200 mm and you want to add a formula-driven parameter Shelf_Span that equals the total width minus twice the bracket thickness (Bracket_Thickness = 25 mm). Write the formula and calculate the resulting Shelf_Span.

Show answer

The formula entered in the Family Types dialog would be: Shelf_Span = Total_Width − 2 × Bracket_Thickness. Substituting the values: Shelf_Span = 1200 mm − 2 × 25 mm = 1200 mm − 50 mm = 1150 mm. In Revit's formula syntax, you would type: Total_Width - 2 * Bracket_Thickness. Note that Revit automatically handles units because both parameters are of type Length. The Shelf_Span parameter should then be labeled to the dimension between the inner faces of the two bracket reference planes.

Question 3: INTERMEDIATE

You're building a parametric display pedestal family. It has a Type parameter Pedestal_Height and you want the top platform to have a chamfered edge whose chamfer size is always 1/10 of the height, but never less than 10 mm or more than 50 mm. Write a Revit formula for a parameter called Chamfer_Size that enforces these constraints.

Show answer

Revit's formula syntax supports nested if-statements. The formula would be: if(Pedestal_Height / 10 < 10 mm, 10 mm, if(Pedestal_Height / 10 > 50 mm, 50 mm, Pedestal_Height / 10)). This reads as: if one-tenth of the height is less than 10 mm, use 10 mm; else if one-tenth of the height exceeds 50 mm, use 50 mm; otherwise, use the calculated one-tenth value. For a Pedestal_Height of 300 mm, Chamfer_Size = 30 mm. For 800 mm, it would be capped at 50 mm. For 80 mm, it would be floored at 10 mm. This clamping strategy prevents the chamfer from becoming visually insignificant or overwhelming the form.

Question 4: APPLIED

A museum client asks you to create a single Revit family for an artwork information plaque that can be wall-mounted at different heights throughout the gallery. The plaque dimensions (width and height) should be consistent across all plaques of the same type, but the mounting height from finished floor must vary per placement. Additionally, the curator needs to schedule each plaque's 'Artist Name' and 'Medium' in a Revit schedule. Describe which parameters you would create, their scope (Family vs. Shared), and their Type/Instance classification.

Show answer

You would create the following parameters. Plaque_Width (Type, Family parameter): shared across all instances of a given plaque size, drives geometry only—no need for scheduling. Plaque_Height (Type, Family parameter): same rationale as width. Mounting_Height (Instance, Family parameter): varies per placement so each plaque can be positioned individually; if the curator also needs this in schedules, make it a Shared parameter instead. Artist_Name (Instance, Shared parameter, Text type): must be Shared so it appears in schedules and tags; Instance because each plaque displays a different artist. Medium (Instance, Shared parameter, Text type): same reasoning as Artist_Name. The key insight is the distinction between geometric parameters (which can remain Family-scoped) and data parameters intended for documentation (which must be Shared). Making Artist_Name and Medium Instance parameters allows each physical plaque to carry unique information.

Question 5: CRITICAL THINKING

A colleague has built a parametric bookshelf family, but it breaks whenever the Shelf_Count parameter (an Integer) is set to 1. The family works fine for values of 2 through 6. The shelves are positioned using the formula Shelf_Spacing = (Total_Height - 2 * End_Panel_Thickness) / (Shelf_Count - 1). Diagnose the problem, explain why it occurs, and propose a solution that allows Shelf_Count = 1 to work correctly.

Show answer

The problem is a division-by-zero error. When Shelf_Count = 1, the denominator (Shelf_Count − 1) equals 0, and Revit's formula engine cannot evaluate the expression. This is analogous to dividing by zero in any mathematical context—the result is undefined. The solution requires a conditional formula that handles the edge case:

if(Shelf_Count = 1, (Total_Height - 2 * End_Panel_Thickness) / 2, (Total_Height - 2 * End_Panel_Thickness) / (Shelf_Count - 1))

. When only one shelf exists, this formula places it at the midpoint of the available space, which is a reasonable default. Alternatively, the designer could prevent the problematic input entirely by adding a note in the family's description that Shelf_Count must be ≥ 2, but the conditional approach is more robust and user-friendly. This scenario illustrates a broader principle: always test parametric families at their extreme values (minimum, maximum, and boundary cases) during the flex test.

SUMMARY

Lesson Summary

Summary

This lesson introduced the parametric engine at the heart of Revit families. A parameter is a named variable that stores a value—a length, material, or toggle. A labeled dimension binds that parameter to the distance between two reference planes, and geometry locked to those planes moves in response. This parametric chain (parameter → label → dimension → reference plane → geometry) is the fundamental workflow for every Revit family you will ever build.

You learned to distinguish Family parameters (internal, not schedulable) from Shared parameters (schedulable, taggable) and to choose between Type parameters (shared by all instances of a type) and Instance parameters (unique per placement). You practiced formula-driven parameters including conditional expressions, built a parametric picture frame in a worked example, and explored how these fundamentals connect to advanced tools like Dynamo, adaptive components, and the Revit API. Always validate your families with a thorough flex test before loading them into a project.