Building from Line — Detailed User Guide

Draw one closed outline. Get levels, grids, columns, beams, walls, a foundation slab, floors, a real hip roof and windows — as native Revit elements.

Overview

Building from Line turns a single closed loop of model lines into a complete, native Revit building. You select the outline once; the plugin opens a window with eight independent generator sections, a live 2D floor-plan preview and a live 3D preview. Each section can be run on its own, or all of them in order with one RUN ALL button:

• Levels — edit, add, rename and delete levels in a dedicated grid; tick which levels the building is built on
• Grids / Axes — an X/Y axis raster over the outline, editable by dragging axes or typing dimensions, and creatable as real Revit grids
• Columns & Beams — perimeter beams, beams along grid axes, columns at axis intersections and at outline corners, grouped per level
• Walls — exterior walls along every outline edge, in one piece or split per level
• Foundation — a slab on the lowest enabled level with its own vertical offset
• Floors — intermediate floors on every enabled level plus a separate top floor under the roof
• Roof — a real hip roof computed with a straight-skeleton solver, or a flat roof with a parapet ("atika")
• Windows — per-edge window counts, spaced evenly along the edges you mark green in the preview

Massing a building in Revit by hand means drawing the same outline again for every level, every slab and every roof, then constraining walls, hosting windows and keeping everything in sync as the footprint changes. Building from Line reads the outline geometry once and derives all of it — wall centerlines, slab boundaries, roof footprint and slope, column and beam positions, window host points — so a first massing that normally takes an afternoon takes a few clicks.

Just as important: the plugin is non-destructive and re-runnable. Every element it creates is either placed inside its own named group (ArchPlug_Foundation, ArchPlug_Walls, ArchPlug_Roof, ArchPlug_Floor_…, ArchPlug_Struct_…) or tagged in its Comments parameter. Running a step again deletes only the plugin's own previous output for that step and rebuilds it — never duplicating, and never touching anything you modelled yourself.

Key Benefits & Use Cases

Who it's for

• Architects who need a correct volumetric model early — for a competition entry, a feasibility study, a client meeting or a first area check — without spending a day modelling it.
• BIM modelers setting up a project skeleton: levels, grids, structure and envelope, ready to be refined instead of built from zero.
• Developers and project leads testing footprint variants: change the outline, re-run, compare.

Concrete scenarios

• First massing: draw the footprint as model lines, run the plugin, get a five-storey building with walls, slabs, a hip roof and windows in under a minute.
• Footprint iteration: move the model lines in the plan, press RUN ALL — the whole building follows the new outline, with the same settings.
• Structural skeleton: use only the Grids / Axes and Columns & Beams sections to lay a column raster and perimeter/axis beams across every level, correctly constrained base-to-top.
• Roof study: mark individual edges red in the plan preview to make them sloped and leave others flat; the straight-skeleton solver produces correct hips and valleys even on L- and T-shaped plans.
• Facade rhythm: type a window count per edge (for example 4 on the street facade, 2 on the side) and see them distributed evenly in the 3D preview before anything is placed in the model.

Requirements

• Autodesk Revit 2022 – 2027 (Windows). Revit is Windows-only, and so is the plugin.
• The plugin is part of the ArchPlug suite and installs into the shared ArchPlug ribbon tab alongside other ArchPlug tools.
• Your project must contain the types the sections you enable will use: a Wall type, a Floor type, a Roof type (a Basic Roof, not Sloped Glazing), a Window family, and Structural Framing / Structural Column families if you use the Columns & Beams section. The plugin places types that are already loaded in your model — it does not ship or load families itself.
• Your project needs at least two levels for floors, walls and windows (a base and something above it).

Installation

1. Run the provided Setup.exe installer and follow the prompts. It installs the plugin, the shared ArchPlug Core runtime and the ArchPlug Settings hub.
2. If Revit was closed during installation, no further steps are needed — the plugin is available the next time you start Revit. (A restart is only needed if Revit was running during the install.)
3. Open Revit and look for the ArchPlug tab on the ribbon. Building from Line appears there as its own button in the Generators panel.
4. Click the button to open the main window.

Getting the Outline In

The plugin is driven by one closed loop of model or detail lines — the building footprint.

1. Draw the footprint in a plan view with any line tool (Architecture → Model Line, or detail lines). Endpoints must meet exactly; a gap of even a millimetre breaks the loop.
2. Select the lines and click the plugin button. The plugin validates the loop, binds the lines into a model group named ArchPlug_Outline, and opens the window.
3. If you launch the plugin without a selection, it finds the existing ArchPlug_Outline group by itself — so on the next session you just press the button. Selecting a new set of lines always wins and replaces the old outline.
4. Because the outline lives in a group, you can move or reshape it later in Revit; the plugin re-reads it and the building follows on the next run.

If the selected lines do not form a closed loop, the plugin says so explicitly: "Selected lines do not form a closed loop. Make sure endpoints meet exactly (no gaps)."

User Interface Walkthrough

The plugin opens a single window titled "ArchPlug – Building from Line". Key characteristics:

• Modeless — the window floats above Revit and stays open while you keep working: you can pan, zoom and change views with it open. Every model-writing action is queued through Revit's external-event mechanism, so operations always run in a valid API context and in the order you triggered them.
• Resizable, with draggable splitters — the window is split into three panes: the section accordion (top left), the 2D plan preview (bottom left) and the 3D preview (right). Drag the splitter bars to give any pane more room; their positions are remembered.
• No OK/Cancel — each section has its own RUN, plus a global RUN ALL at the bottom right. Running never closes the window, so you can iterate: change a value, run, inspect, change again.
• Everything persists — window position and size (including maximized state), splitter positions, every field, every section check-box and the 3D display mode are stored in %APPDATA%\ArchPlug\building.json, separately from the plugin code. Updating the plugin never resets your settings.
• Status line at the top shows the current outline: "Selected loop: 4 segments | bbox 23.3 x 18.9 m", and after a run it reports what happened. There is no success pop-up.

The section accordion

Each section is a collapsible orange bar. Click the bar to expand or collapse it ([ + ] / [ - ]). Every bar carries two controls:

• a check-box on the left — includes or excludes that step from RUN ALL. Unticking it also dims that section's RUN button.
• a RUN button on the right — executes only that step, immediately, without touching the others.

"Levels" (opens its own window)

The Levels bar opens a separate ArchPlug – Levels window containing an editable grid of all levels in the project:

Buttons: + Add level, Delete selected (removes the level from Revit, with a confirmation), Check all, Uncheck all, Apply to Revit and Close. Hold Shift or Ctrl to select several rows — toggling one check-box then applies to the whole selection. Closing the Levels window refreshes the 3D preview automatically.

"Grids / Axes"

Axes are fully editable directly in the 2D preview — see The 2D plan preview below.

"Columns & Beams"

Structure is created per enabled level and grouped per level as ArchPlug_Struct_<level>. Columns span from their level to the next enabled level above; no column is created on the topmost level (it would have zero height). Define your axes in Grids / Axes first — both the preview and the model output use exactly the same geometry engine, so what you see is what gets built.

"Walls"

"Foundation"

"Floors"

"Roof"

The two parameter groups swap automatically with the selected mode, so only the fields that apply are visible.

"Windows"

Which edges get windows, and how many, is set directly in the 2D preview: enable an edge with its green box, then type the number of windows for that edge in the small field beneath it. The plugin spaces them evenly along the edge.

The 2D plan preview

The lower-left pane is a true-to-scale plan of the outline — walls, columns, beams and windows are drawn at the real width of the chosen family types, so proportions match the model.

• Pan with the middle mouse button, zoom to the cursor with the wheel.
• Two boxes per edge: a green box enables windows on that edge, a red box makes that edge a sloped roof edge. A small number field under the green box holds the window count for that edge.
• Grid axes live in the drawing — their bubbles and dimension strings pan and zoom with the plan. Hover an axis and the cursor changes; drag it to move it. Hover a dimension and it highlights; double-click it, type a value in metres and press Enter to place the axis exactly.
• Dragging an axis that lies on an outer wall moves that wall — the outline itself changes and the whole building follows.
• Undo / Redo with Ctrl+Z / Ctrl+Y while the plugin window has focus. This affects only your edits inside the plugin (axes, edge flags, window counts) — it never touches Revit's own undo stack.
• A legend shows what each colour means: Windows, Roof slope, Beams, Columns.

The 3D preview

The right-hand pane is a live wireframe/solid view of the building the plugin would create — levels, walls, windows, roof planes, columns and beams — rebuilt instantly whenever you change anything. It needs no Revit view and creates nothing in the model.

• Left-drag rotates, right-drag or middle-drag pans, wheel zooms.
• Three small buttons in the bottom-left corner switch the display mode: wireframe, hidden line and shaded. The chosen mode is remembered.
• The camera starts facing the front facade so the view matches the plan below it.

Step-by-Step Workflow

1. Draw the footprint as a closed loop of model lines in a plan view.
2. Select the lines and launch Building from Line from the ArchPlug ribbon tab. The window opens with your last-used settings and the outline already loaded.
3. Set up levels: open the Levels window, add or edit levels, tick the ones the building uses, press Apply to Revit, then close it. The 3D preview updates immediately.
4. Type your axis counts in Grids / Axes and fine-tune them in the plan preview by dragging axes or double-clicking their dimensions.
5. Choose the types for each section you want — wall, floor, roof, window, column and beam — and fill in the numeric fields. All lengths are in centimetres unless a label says otherwise; decimal commas are accepted.
6. Mark the edges in the plan preview: green for windows (with a count), red for sloped roof edges.
7. Untick any section you do not want in this pass — for example leave Columns & Beams off for a pure architectural massing.
8. Click RUN ALL. The steps execute in dependency order: Levels → Grids → Columns & Beams → Walls → Foundation → Floors → Roof → Windows. Each step first removes its own previous output, then rebuilds it. Non-critical Revit warnings raised during creation are dismissed silently so the run does not stall on pop-ups.
9. Read the status line — e.g. "Run All: executed 8 step(s)." Errors are reported per step in a dialog naming the step that failed; the remaining steps still run.
10. Iterate: change a value and press that section's own RUN, or move the outline lines in Revit and press RUN ALL again. Nothing duplicates.
11. Close the window with the title-bar X. All settings, previews and window geometry are saved.

Feature Reference

Smart Update (no duplicates, ever)

Every step owns its output and rebuilds only that:

• Foundation, Walls, Roof — each goes into its own model group (ArchPlug_Foundation, ArchPlug_Walls, ArchPlug_Roof). Re-running the step deletes the previous group and creates a new one.
• Floors — a shared floor group copied to every enabled level, or a unique group per level for levels you flagged Unique floor group.
• Columns & Beams — grouped per level as ArchPlug_Struct_<level>; the whole set is wiped by prefix before a rebuild.
• Windows — hosted elements are not grouped (a grouped insert cannot be copied to another host). Instead each window is placed individually per level and marked in its Comments parameter with ArchPlug_Window; re-running deletes exactly those and no others.

Anything you model or edit yourself is never touched, because it carries neither the group name nor the Comments marker.

Real hip roofs (straight skeleton)

The roof is not a naive per-edge offset. The plugin computes a genuine straight skeleton of the footprint — the same algorithm used for roof-surface generation in computational geometry — so ridges, hips and valleys land in the correct places even on L-, T- and U-shaped plans, where simple offsetting produces crossing lines. Every edge you marked red gets the slope angle you typed; the resulting ridge is shown in the 3D preview before anything is created in the model.

One preview engine, one build engine

The column, beam and roof geometry shown in the previews is produced by the same functions that create the Revit elements. The preview cannot drift from the result — if it looks right in the preview, it is what gets built.

The outline group

The footprint lines are bound into a model group called ArchPlug_Outline and its id is remembered between sessions. This is what lets you re-open the plugin without re-selecting anything, and lets you reshape the building later by editing the lines in Revit.

Persistence

All settings live in %APPDATA%\ArchPlug\building.json — separate from the plugin itself. Updating the plugin does not reset your window position, section states or field values. The window position is also validated against the connected screens, so it never opens off-screen after you unplug a monitor.

Tips & Best Practices

• Start with Levels. Almost every other section works on "enabled levels", so get that list right first — it is the fastest way to control how tall the building is.
• Use the section check-boxes as a plan. A quick volume study needs only Walls, Floors and Roof; add Columns & Beams later without redoing anything.
• Set axes by typing, not by eye. Double-click a dimension in the plan preview and type the exact span in metres — faster and more precise than dragging.
• Check the 3D preview before running. It is free: every field change is reflected immediately, so mistakes are caught before a single element is created.
• Reshape rather than rebuild. Move the outline lines in Revit and press RUN ALL; you keep every setting.
• Split walls per level when different storeys will get different wall types later; leave it off for the cleanest single-wall geometry.
• One Ctrl+Z per step. Each step is its own Revit transaction, so undo is granular — you can undo just the roof without losing the walls.

Troubleshooting & FAQ

"Selected lines do not form a closed loop." The endpoints of your footprint lines do not meet exactly. Use snaps, or trim/extend the lines, and select them again. Arcs are supported; gaps are not.

"No model/detail lines in selection." The selection contains other elements only. Select the footprint lines themselves — not a filled region, not a room boundary.

"No enabled levels." Nothing is ticked in the Use column of the Levels window. Tick at least one level (two for floors, walls and windows).

"Need at least 2 enabled levels." Floors, walls and windows need a level to start from and one above it. Add a level or tick another one.

"Floor type not found" / "Wall type not found" / "Roof type not found" / "Window family not found". The type selected in that drop-down no longer exists in the project — usually because the settings came from another project. Re-pick a type from the drop-down.

The roof step fails or produces nothing. Check that the selected roof type is a Basic Roof. The first roof type in many templates is Sloped Glazing, which is a curtain system and not a footprint roof.

"No axes defined. Type X/Y counts first." The Grids RUN button was pressed while both counts are 0. Type a count and the axes appear in the preview immediately.

"No window placements (enable an edge and set a count > 0)." No edge is marked green, or every green edge has a count of 0. Click the green box on an edge in the plan preview and type a number underneath it.

No columns appear on the top level. By design — a column on the highest level would have zero height, which Revit rejects (and a failed column would break the whole level group). Columns run from each level to the next enabled level above.

Can I undo a run? Yes. Each step is committed as its own Revit transaction, so one Ctrl+Z in Revit (with the model window focused) reverses that step. Ctrl+Z while the plugin window has focus instead undoes your edits inside the plugin's plan preview.

Does re-running duplicate elements? No. Every step deletes its own previous output before rebuilding — groups by name, windows by their Comments marker. Elements you created yourself are never affected.

Can I keep working in Revit while the window is open? Yes — the window is modeless. Pan, zoom and change views freely. Model changes requested from the plugin are queued and executed in order in a valid Revit API context.

The window opened on the wrong monitor / off-screen. The window restores its last position but verifies it is still visible on a connected screen; if not, it opens centred instead.

Why are some Revit warnings not shown? Non-critical warnings raised while grouping and placing elements are dismissed automatically so a long run never stalls waiting for a click. Real errors are still reported.

Where are my settings stored? In %APPDATA%\ArchPlug\building.json. Deleting that file resets the plugin to its defaults.