Historical Context & Motivation
Before parametric modeling existed, architects and designers who wanted to change a door's width on a construction drawing had to erase every occurrence of that door and redraw it—a laborious, error-prone process that could consume hours of production time. The concept of parametric families arose from the desire to embed intelligence into building components so that a single edit could propagate logically throughout an entire project. Understanding this lineage clarifies why Autodesk Revit distinguishes between type parameters and instance parameters—two mechanisms that control the scope of change within a Building Information Model.
The central question that parametric families answer is deceptively simple: When I change a property of a building element, should that change affect every element of the same kind, or only the specific element I selected? Revit's answer—splitting parameters into types and instances—provides the granular control that makes BIM powerful for design iteration, documentation, and fabrication alike.
Core Principles & Definitions
In Revit's data architecture, every element placed in a project is an instance of a family type. A family type is a template that defines shared characteristics—dimensions, materials, and behavioral rules—while each instance is a concrete placement in the model with its own location, orientation, and instance-specific data. Parameters are the named variables that store this information, and their classification as type or instance determines the scope of any edit you make.
Family
Type
Instance
Type Parameter
Instance Parameter
Visual Explanation — Type vs. Instance Hierarchy
Notice how the hierarchy fans outward from abstraction to specificity. The family sits at the top as the broadest container—it holds the geometric engine, the constraints, and the parametric rules that define how the element behaves. Beneath it, each type freezes certain values (width, height, material) into a named configuration that serves as a reusable template. Finally, each instance is a concrete occurrence in the model—tied to a specific host wall, assigned to a specific level, and carrying its own per-placement data like offset or orientation. This layered architecture is what allows Revit to manage thousands of elements efficiently while still giving designers element-by-element control when they need it.
How It Works — Editing Type vs. Instance Parameters
When you select an element in Revit and open the Properties palette (the panel typically docked on the left side of the interface), you see that element's instance parameters—values unique to that particular placement. To access the type parameters, you click the Edit Type button at the top of that palette, which opens the Type Properties dialog. This two-panel interface is the fundamental mechanism through which Revit separates local edits from global ones, and understanding when to use each panel is essential to effective parametric modeling.
Editing Type Parameters
The Type Properties dialog displays every parameter classified as a type parameter for the selected family type. When you modify a value here—say, changing the Width of a door from 900 mm to 1000 mm—Revit applies that change to every single instance of that type across the entire project. If your model contains forty doors of that type, all forty update simultaneously. This is powerful for maintaining design consistency, but it demands caution: an unintended type edit can ripple through hundreds of elements before you realize what happened. Revit does warn you with a count of affected instances when applicable, but cultivating awareness of this propagation behavior is a core professional skill.
Editing Instance Parameters
Instance parameters appear directly in the Properties palette when an element is selected. Changes here affect only the selected element (or the set of selected elements, if you have multiple items highlighted). Typical instance parameters include Level, Offset from Level, Mirrored, and Comments. These values inherently depend on the element's unique position in the model—no two doors necessarily share the same sill height or the same wall host, so it makes logical sense for these to vary per instance.
Duplicate Type Workflow
A critical workflow arises when you need a variation that differs from an existing type in one or more type parameters but want to preserve the original. Rather than editing the existing type (which would change every instance), you duplicate the type first. In the Type Properties dialog, clicking Duplicate creates a new type that inherits all current values. You then rename it, adjust the differing parameters, and assign the new type to the relevant instances. This preserves design intent for the original type while accommodating the variation.
Detailed Breakdown — Common Parameters by Category
Different Revit family categories assign parameters to the type or instance bucket based on the logic of how that property naturally behaves in a real building. A door's nominal width is a product specification—it belongs to the type. A door's position in a wall depends on the specific wall it is hosted in—it belongs to the instance. The following table maps commonly encountered parameters across several family categories, showing where each parameter lives and why that classification makes sense.
| Family Category | Typical Type Parameters | Typical Instance Parameters |
|---|---|---|
| Doors | Width, Height, Material, Fire Rating, Frame Type, Manufacturer | Level, Sill Height, Head Height, Mirrored, Comments, Mark |
| Windows | Width, Height, Glazing Type, Frame Material, U-Value, SHGC | Level, Sill Height, Head Height, Offset from Host, Comments |
| Walls | Structure (layers and thicknesses), Function, Wrapping | Base Constraint, Top Constraint, Base Offset, Unconnected Height, Location Line |
| Furniture | Width, Depth, Height, Material/Finish, Model, Cost | Level, Offset from Level, Rotation, Comments |
| Columns | Cross-section dimensions, Material, Structural usage | Base Level, Top Level, Base Offset, Top Offset, Rotation |
The decision diagram above encapsulates the mental model you should internalize every time you modify a parameter in Revit. Beginning designers often skip the "Does this change apply to all?" question and inadvertently alter a type parameter when they meant to adjust only a single element. Conversely, experienced practitioners leverage type edits strategically—for example, updating a window family's glazing performance data across an entire project in seconds rather than selecting each window individually.
Worked Example — Editing Door Parameters in a Gallery Project
Imagine you are designing a small art gallery in Revit. The gallery has twelve interior doors, all currently using the type "Single-Flush: 900 × 2100 mm" with an Oak material finish. The client requests two changes: (1) all interior doors should be widened to 1000 mm to improve accessibility, and (2) one specific door leading to a service corridor should have its sill height raised by 50 mm to clear a floor transition. Let's walk through both edits step by step.
Strengths & Limitations — Type vs. Instance Parameters
| Criterion | Type Parameters | Instance Parameters |
|---|---|---|
| Scope of change | Global—affects every instance of that type in the project | Local—affects only the selected element(s) |
| Efficiency for bulk edits | Very high—one edit, hundreds of updates | Low—must select and edit each element individually or use Select All Instances |
| Risk of unintended changes | High—accidental type edits cascade project-wide | Low—changes are contained to the selection |
| Scheduling / tagging | Reported identically for all instances of a type in schedules | Can vary per row in a schedule, enabling element-specific annotations |
| Typical use cases | Product dimensions, materials, manufacturer data, structural properties | Placement location, offset, orientation, unique identifiers (Mark), comments |
| Where to edit | Type Properties dialog (Edit Type button) | Properties palette (direct selection) |
Connection to Advanced Topics — Shared, Project, and Global Parameters
The type-vs-instance distinction is the foundation of Revit's parameter system, but the platform offers additional layers of complexity that build on this foundation. As you advance in BIM authorship, you will encounter shared parameters, project parameters, and global parameters—each of which can be assigned as either type or instance. Understanding the base-level distinction makes these advanced tools immediately more approachable.
| Parameter Category | Scope | Type or Instance? | Key Characteristic |
|---|---|---|---|
| Family Parameters (built-in) | Within one family | Either—defined in Family Editor | Embedded in the .rfa file; cannot be scheduled across families without being shared |
| Shared Parameters | Across families and projects | Either—specified when added | Stored in external .txt file; can appear in schedules and tags across multiple families |
| Project Parameters | One project only | Either—specified when created | Added to categories within the project; schedulable but not taggable unless shared |
| Global Parameters | One project, no category | Neither—project-level constants | Named values (like a corridor width standard) that can drive other family parameters through formulas |
When creating custom families in the Family Editor—a skill you will develop as you progress in architectural visualization and design technology courses—you will make deliberate decisions about whether each parameter should be type or instance. For example, if you are authoring a custom gallery display case family, the overall cabinet dimensions (width, depth, height) might be type parameters so that all cases on one floor share a uniform appearance, while an internal shelf count could be an instance parameter if different cases need to accommodate artworks of varying sizes. This forward-looking perspective—designing the parameter structure before modeling the geometry—is a hallmark of mature BIM practice.
Practice Problems
Summary — Type vs. Instance Parameters
Revit's parameter system is organized around a three-tier hierarchy: Family (the broadest class of element), Type (a named variant defined by its type parameters such as dimensions, materials, and performance data), and Instance (a single placement carrying instance parameters like level, offset, orientation, and unique identifiers). Editing a type parameter in the Type Properties dialog propagates the change to every instance of that type across the entire project, making it powerful for bulk updates but risky if performed unintentionally. Editing an instance parameter in the Properties palette affects only the selected element, providing precise per-element control.
The key professional habit to develop is pausing before every edit to ask: "Should this change affect all instances of this type, or just this one?" When you need a variation that differs from an existing type but want to preserve the original, the correct workflow is to duplicate the type before modifying its parameters. This foundational understanding extends naturally into advanced topics such as shared parameters, project parameters, and global parameters—all of which inherit the type-vs-instance classification and amplify its power across families and projects.