Day 4 — Families and parameters

Today is the unlock. Families are where Revit stops being a modeling program and starts being a system you can bend. It's also where most self-taught users have the biggest gap — they can place a family but not make one, so they work around limitations forever.

The Family Editor is a different program

File → New → Family gives you a list of .rft family templates. Choosing the right one is the most consequential decision you'll make, because it sets:

• The category (and therefore how it schedules, tags, and draws)
• Whether it's hosted (wall-based, ceiling-based, face-based) or free-standing
• Whether it's model or annotation (annotation scales with the view; model geometry is real size)

You cannot change model↔annotation later. You can change category, but hosting is baked in. If you pick "Generic Model" because you're unsure, you've created something that won't schedule with doors or tag with a door tag.

Common templates:

The workflow that produces a family that actually flexes

The order matters. Do it in this order every time:

1. Reference planes first

Draw reference planes (RP) where the important faces of your object will be. Then — and this is the step everyone skips — name them in the Properties palette. Named planes can be picked in dimension and constraint dialogs; unnamed ones can't.

2. Dimension between planes, then label

Add dimensions (DI) between reference planes. Select a dimension and use the Label dropdown in the Options bar to attach it to a parameter, creating one inline if needed. Now the parameter drives the plane.

3. Flex before you model any geometry

Open Family Types (the dialog with all your parameters), change the values, click Apply. Your reference planes should move. If they don't move, or Revit throws a constraint error, fix it now — before there's geometry attached to them.

This is the single most valuable habit in family authoring. Debugging a broken family with geometry in it is ten times harder.

4. Build geometry, locked to the planes

Now create the solid (Create → Extrusion, Blend, Revolve, Sweep, or Swept Blend). In sketch mode, draw your profile snapped to the reference planes, and click the padlocks to lock each sketch line to its plane. The padlock is what makes geometry follow the plane.

5. Flex again

Change values, Apply. Geometry should move with the planes. If a face stays behind, that sketch line wasn't locked.

6. Subcategories and visibility

Assign geometry to a subcategory (Object Styles inside the family) so it can be controlled independently in projects. Then use Visibility/Graphics on each solid to set which detail levels it appears at — a Fine-only bolt pattern keeps your 1:100 plans clean.

7. Load into the project

Load into Project. If you're iterating, keep both windows open and reload; Revit asks how to handle overwriting existing types.

Parameter types, and choosing correctly

This is the part worth memorizing, because it's the part that costs real money to get wrong.

Family parameter (type or instance)

Defined inside one family. Lives and dies with that family.

• Type parameter — shared by every instance of the type. Width, height, material, fire rating.
• Instance parameter — unique per placed element. Sill height, comments, a reference number.

The test: would every one of these change together? Yes → type. No → instance.

Project parameter

Added in a project (Manage → Project Parameters) to one or more categories. Schedulable, but not taggable, and it doesn't travel to other projects.

Shared parameter

Defined in an external .txt file with a stable GUID, then added to families and/or as a project parameter. This is the only kind that can be both tagged and scheduled and that means the same thing across families, projects, and schedules.

If you want a parameter to survive real project life, make it shared. This is not optional advice — it's why every firm has a guarded shared parameter file.

Manage → Shared Parameters → Create…
  → RB-SharedParams.txt in your Shared/ folder
  → New Group: "RB General"
  → New Parameter: "RB_AssetTag", type Text

Guard that file. Matching is by GUID, not name. If you lose it and recreate the parameter, you get a new GUID, and Revit treats it as a completely different parameter — your tags go blank and your schedules split into two columns with the same name.

Global parameter

A project-wide value (Manage → Global Parameters) that can drive dimensions and other parameters. One place to set "typical corridor width" and have every constrained dimension follow.

Full comparison in parameters.

Formulas

In Family Types, any parameter can have a formula. Rules:

• Parameter names are case-sensitive and must match exactly. Width ≠ width.
• Conditionals: if(Width > 900 mm, 2, 1). Nest them: if(A, x, if(B, y, z)).
• Boolean operators are and(a, b), or(a, b), not(a) — function form, not &&.
• Common functions: abs, round, roundup, rounddown, sqrt, sin, cos, tan, log, exp, pi().
• Units are enforced. A Length parameter's formula must resolve to a length. Length / Length gives a unitless number — useful for counts. Length * Length gives an area, which Revit will refuse to put in a Length parameter.
• Integer division truncates. roundup(Width / Spacing) is how you count things.

A realistic example — number of shelves from cabinet height:

Shelf Count = roundup((Height - 100 mm) / Shelf Spacing) - 1
Show Handle = Width > 400 mm

Show Handle as a Yes/No parameter can drive a solid's Visible property, so geometry appears and disappears based on size. That's the trick behind most sophisticated families.

Types inside the family vs. a type catalog

You can define types in Family Types — good for 3–10 variants. Beyond that, use a type catalog: a .txt file sitting next to the .rfa with the same base name, one row per type. Revit shows a picker on load so users only bring in the types they need.

,Width##length##millimeters,Height##length##millimeters,Shelf Count##other##
600x900,600,900,3
900x900,900,900,3
1200x1200,1200,1200,4

That header syntax (##type##units) is fussy and unforgiving. When a catalog doesn't load, it's the header.

Family performance rules

Families are where model bloat comes from. Four rules:

1. Void cuts are expensive. Prefer shaping the solid over cutting it.
2. Avoid nested families that are themselves shared unless you need to schedule the nested part separately.
3. Don't import CAD into a family. Ever. It's the most common cause of inexplicable file size and unpurgeable line styles.
4. Use subcategories and detail-level visibility so a complex family draws cheaply at coarse detail.

Today's exercise

Build a parametric shelving unit and wire it into the project's data.

1. File → New → Family → the Casework template for your units.
2. Draw and name reference planes: Left, Right, Front, Back, Top.
3. Dimension between them and label the dimensions with new parameters Width (type), Depth (type), Height (type).
4. Flex it. Change values in Family Types, Apply. Planes should move.
5. Extrude the carcass, locking every sketch line to a reference plane. Flex again.
6. Add a Shelf Count integer parameter with the formula roundup((Height - 100mm) / 300mm) - 1, and an array of shelf extrusions whose array count is labelled with Shelf Count. (Array → select the array → label the array parameter.) Flex it and watch shelves appear.
7. Add a Yes/No parameter Has Doors and drive a door panel solid's Visible property with it.
8. Create your shared parameter file and a shared parameter RB_AssetTag (Text, instance). Add it to the family.
9. Create three types: 600x900, 900x900, 1200x1200.
10. Load into project. Place three instances, give each a different RB_AssetTag value.
11. Add a generic annotation tag or use Tag by Category with a Casework tag to display RB_AssetTag on plan. If you don't have one, create a tag family from the Annotation Symbol / generic tag template with a label bound to the shared parameter. This step is the payoff — it's proof the shared parameter works end-to-end.
12. Create a quick schedule (View → Schedules → Schedule/Quantities → Casework) with Type, RB_AssetTag, and Count. Confirm your values appear.

Save the family into Families/ and save the project. You now understand the part of Revit most users never touch.