Historical Context & Motivation
Before parametric modeling software existed, architects and designers drafted every variation of a building component — a door, a window, a piece of furniture — as a separate drawing. If a client wanted a narrower window, the designer literally redrew it from scratch. This tedious redundancy consumed enormous amounts of time and introduced inconsistencies across drawing sets. The emergence of Building Information Modeling (BIM) in the late twentieth century promised a radically different paradigm: a single intelligent model where changing one dimension would ripple through every affected view, schedule, and detail automatically.
Autodesk Revit, first released in 2000 by Charles River Software, was conceived from the ground up as a parametric BIM platform. Unlike AutoCAD — where geometry is essentially a collection of lines and arcs — Revit treats every building element as a family: a rule-driven template that can generate multiple family types (sometimes called "type variations") from a single definition. Understanding how to create and test these types is foundational to professional Revit work and, increasingly, to digital design in the visual arts.
The central question this lesson addresses is deceptively simple: how do you create multiple variations of a Revit family and verify that each variation behaves correctly when its parameters change? Answering it well separates novice Revit users from those capable of producing robust, production-ready content.
Core Principles & Definitions
Before diving into the mechanics, you need a clear vocabulary. A Revit family is a template file (.rfa) that defines the geometry, parameters, and behavioral rules for a category of building elements — think of it as a master mold from which individual pieces are cast. Within that family, a family type is a named preset of specific parameter values: a particular width, height, material, or any other variable you've exposed. When you load a family into a Revit project, each type appears as a selectable option in the Type Selector — the dropdown you click when placing a door, window, or furniture piece.
Family (.rfa)
Family Type
Parameters
Flexing
Reference Planes & Constraints
Visual Explanation — Anatomy of a Family Type
Notice how the family file sits at the top of the hierarchy, acting as the single source of geometric logic. Each family type inherits the same reference-plane skeleton and constraint rules but populates them with different numeric and material values. The flexing test row at the bottom represents the critical quality-assurance step: switching between types in the Family Editor and verifying that the geometry regenerates without errors. A failed flex test — represented here by the red dashed border on Type C — signals that a constraint is over-determined, an equality is unsatisfiable at that size, or geometry is colliding in ways the parametric logic cannot resolve.
How Family Types Work — The Parametric Engine
Revit's parametric engine operates on a system of constraints — dimensional locks, alignments, and formulas that tie geometry to reference planes. When you define a type parameter such as Width = 1200, the engine evaluates every constraint that references Width and repositions the dependent geometry accordingly. If any constraint produces a contradiction — for instance, a minimum clearance rule that cannot be satisfied at the given Width — the engine throws a warning. Understanding this mechanism is essential because the order in which you build constraints directly determines whether your family flexes successfully.
Parameter Types and Scope
Revit distinguishes between type parameters and instance parameters. A type parameter is shared by every instance of that type placed in the project — change the Width of "Type B: Medium" and every Medium table in the model updates. An instance parameter, by contrast, can differ from placement to placement: you might allow the user to override the table's rotation angle per placement without affecting the others. When creating family types, your primary concern is type parameters, because each type is essentially a saved snapshot of all type-parameter values.
Formula-Driven Parameters
Width * 0.667 in the formula column of the Family Types dialog.if(Width > 1500 mm, Yes, No) in Revit's formula field.Detailed Breakdown — The Flexing Workflow
Creating a family type is only half the job; the other half — and arguably the more important half — is flexing. Flexing means systematically changing parameter values across all your types and verifying the geometry updates without errors. Professional Revit content creators flex at multiple stages: after adding each new constraint, after introducing formula-driven parameters, and in a final comprehensive pass before loading the family into a project.
Step-by-Step Type Creation in the Family Editor
- Open Family Types dialog — in the Family Editor ribbon, click
Create > Family Types(or press keyboard shortcut). The dialog lists all current types and their parameter values in a spreadsheet-like interface. - Add a new type — click
New...at the top of the dialog. Enter a descriptive name such as "1200 × 800 Walnut" that communicates key parameter values at a glance. - Set parameter values — with the new type selected, enter values for Width, Depth, Height, Material, and any other exposed parameters. Formulas will compute automatically for derived parameters.
- Apply and verify — click
Apply(not OK) to update the geometry in the background views while keeping the dialog open. Switch to a plan or 3D view behind the dialog to inspect the result. - Repeat for each type — create all planned types, then cycle through each one using the type dropdown at the top of the dialog, clicking
Applyafter each switch to confirm the geometry regenerates correctly.
Worked Example — Creating a Gallery Pedestal Family
Imagine you are designing a series of gallery pedestals for a contemporary art exhibition. The curator wants three sizes — Small (for jewelry), Medium (for sculpture), and Large (for mixed-media pieces) — and the fabricator needs each size fully documented in Revit with accurate dimensions and material data. Let's walk through the process of building this family with three types and flexing each one.
File > New > Family. Select the Metric Generic Model.rft template (or the Imperial equivalent). This template provides two intersecting reference planes — the horizontal and vertical center — which you'll use as the origin for all geometry.Create > Family Types). Click New... and name the first type "Small — 300 × 300 × 900". Set Width = 300, Depth = 300, Height = 900. Create a second type "Medium — 450 × 450 × 750" and a third "Large — 600 × 600 × 600". Optionally add a Material parameter of type "Material" and assign Painted White, Raw Birch Plywood, and Brushed Stainless Steel to each type respectively.Apply. Look at the 3D view: the pedestal should display as a 300 × 300 × 900 box. Switch to "Medium" and apply — the box should shrink in height and widen. Finally switch to "Large" — the box should become a 600 × 600 × 600 cube. If any switch triggers a Revit warning dialog ("Constraints not satisfied"), you have an over-constrained or under-constrained dimension. Return to the elevation and plan views, check that all sketch lines are locked to reference planes, and verify your equality constraints are intact.Strengths, Common Pitfalls, and Comparisons
Revit family types offer tremendous workflow advantages, but they come with pitfalls that can frustrate newcomers — especially designers from visual arts backgrounds who may be more accustomed to direct-modeling tools like SketchUp or Rhino. The following table outlines the key strengths and limitations of the family type system.
| Strengths | Limitations | Mitigation |
|---|---|---|
| One file manages dozens of variations — no file-proliferation chaos | Complex families with many types can become slow to open and edit | Limit types to genuinely needed sizes; use instance parameters for one-off adjustments |
| Schedule data (sizes, materials, costs) updates automatically per type | Incorrect parameter grouping can cause schedule fields to be blank or misaligned | Always assign parameters to the correct group (Dimensions, Materials, Identity Data, etc.) |
| Formula-driven relationships enforce design intent across all types | Circular references in formulas cause Revit to reject the family outright | Map parameter dependencies linearly; never reference a parameter within its own formula chain |
| Flex testing catches errors before the family reaches the project environment | Forgetting to flex is the #1 source of family errors in production | Adopt a habit: flex after every constraint change, not just at the end |
| Types appear as dropdown options in the project, simplifying placement for team members | Naming conventions can become inconsistent across different family authors | Establish a firm naming standard (e.g., "Width × Depth × Height — Material") and enforce it |
Connection to Advanced Family Concepts
Once you have mastered the fundamentals of creating family types and flex-testing them, the next layer of complexity involves shared parameters, nested families, and type catalogs. These advanced features build directly on the type-creation skills you've developed in this lesson — each one is essentially a more powerful way to manage the same parametric logic.
| This Lesson | Advanced Extension |
|---|---|
| Types defined manually in the Family Types dialog | Type Catalogs (.txt) — external text files that auto-generate hundreds of types on load, used for product libraries |
| Parameters scoped within a single family file | Shared Parameters — parameters stored in an external file and reusable across families, enabling cross-family scheduling |
| Single-geometry family with dimensional variation | Nested Families — swapping sub-components (e.g., different leg styles) within a host family using a family-type parameter |
| Flex testing done manually by switching types | Dynamo Scripting — automating flex testing by programmatically iterating through parameter ranges and flagging failures |
For visual arts students, the most immediately relevant advanced topic is often nested families. Consider an exhibition display system where the base pedestal is one family and the vitrine (glass case) is another. By nesting the vitrine inside the pedestal family, you can create types like "Pedestal with Vitrine" and "Pedestal Open Top" within a single host family — all while maintaining independent flex behavior for each nested component. This modular approach mirrors the compositional thinking central to visual arts practice: assembling complex wholes from discrete, well-crafted parts.
Practice Problems
Bracket_Depth = Shelf_Width × 0.75. You create three types with Shelf_Width values of 200 mm, 400 mm, and 600 mm. What will the Bracket_Depth be for each type?Lesson Summary
This lesson explored how to create family types in Autodesk Revit — named presets of type parameter values within a single family file (.rfa). We examined the historical evolution from manual drafting to parametric BIM, defined the core vocabulary (family, type, parameter, constraint, reference plane), and traced the complete workflow from building reference-plane skeletons to assigning formula-driven parameters that enforce proportional relationships across types.
Critically, we emphasized that flexing — the systematic testing of each type by switching parameter values and verifying geometry integrity — is the quality-assurance step that separates reliable families from fragile ones. The flexing checklist (minimum values, maximum values, intermediate values, and visibility toggles) provides a repeatable protocol for validation. Looking ahead, these foundational skills prepare you for advanced topics such as nested families, type catalogs, and shared parameters — each of which extends the parametric logic you've learned here into larger, more complex modeling ecosystems.