Manufacturing | Formwork - Automating Complex Deck Formwork with Rhino.Inside.Revit
We pioneered a hybrid geometry architecture that leverages a headless Rhino backend to solve complex formwork layouts in seconds. By integrating custom guillotine partitioning algorithms with JSON-defined design rules, we transformed a manual workflow into an automation engine that optimizes standard formwork panel usage and enforces over 1,000 design rule constraints on every solve.
- Client
- Private Client
- Timeline
- 2018 - 2022
- Service
- Custom Applications→
The Engineering Challenge
A global leader in aluminum formwork manufacturing faced a significant operational bottleneck. Their design team spent hours — sometimes days — manually placing standardized components (ceiling panels, beam soffits, soffit lengths, and corner components spanning roughly 100 distinct types) to cover complex ceiling surfaces - known in formwork as the "deck" - in Revit. The task was geometrically intense: finding the optimal layout for arbitrary rectilinear shapes while respecting over 1,000 engineering rules and structural constraints. Coverage had to be complete: formwork is the mold concrete is poured into, so the layout must cover every ceiling surface with zero gaps, resorting to non-standard panels only where standard dimensions cannot fit.
The problem was that the Revit API was fundamentally unsuited for this challenge. It lacked the advanced surface splitting, Boolean operations, and geometric tolerance required to solve complex intersections reliably. The client needed a solution that could "think" like a geometric solver but live inside Revit.
We knew this firsthand. The first iteration of the tool, piloted in 2018, was developed on the Revit API alone: its limited repertoire of geometric methods forced constant workarounds, bloating the codebase with complex classes that were slow and difficult to maintain. Worse, the same formwork condition can be represented in a Revit model in many different ways, and that variation kept breaking the algorithms. In 2020 we refactored the geometry core onto Rhino.Inside.Revit, then newly available in alpha.
The Solution Architecture
We engineered the Deck Solver, the first enterprise Revit plugin to embed Rhino.Inside.Revit as a headless geometry engine. To the user, it is a seamless Revit plugin; under the hood, it is a high-performance Rhino application.
Hybrid Geometry Pipeline
We developed a unique architecture that extracts geometry from Revit but processes it entirely in RhinoCommon. Rhino.Inside itself is engaged only at startup, as the bridge into RhinoCommon - the dependency on it is minimal by design.
- The Bridge: Upon startup, the tool collects the elements of the architect's concrete shell model - walls, slabs, beams, and columns - within a configurable threshold (1,000mm by default) around each Revit Room's bounding box, and converts them into our internal geometry types. Only spaces where the user has placed rooms receive formwork, reducing memory load on large models; the collection distance is adjustable from the UI.
- Shell Model Unification: The extracted elements are Boolean-unioned into a single watertight Brep with all coplanar edges merged. Multi-layer wall assemblies and complex junctions - around door jambs, for example - make it extremely difficult to know which surfaces should be culled, trimmed, or solved; merging the model into one unified solid removes that ambiguity and simplifies formwork solving.
- Headless Solving: Once converted, the application disconnects from the Revit API. It uses Rhino's advanced Brep (Boundary Representation) kernel to merge, split, and clean the geometry - operations that, while possible in the Revit API, demand significant, highly inefficient workarounds and still lack the tolerances needed for consistent formwork output.
- Indexed Topology: Rhino's Brep structure indexes every face, edge, and vertex — the foundation the solver uses to traverse the model, evaluate interface conditions, and resolve adjacencies. Queries like edge concavity are one-liners in RhinoCommon that would take 15+ lines of custom code against the Revit API, which does not index geometry.
- Metadata Preservation: To maintain the link between the solver and the original BIM data, we invented an IPointReference system. This places metadata markers at the centroid of every source face before merging, allowing the solver to query properties (like element category or Element ID) without ever calling the Revit API.
- The Return Bridge: Only once the solver has found its solution does the application re-engage the Revit API, converting the solved output - deck panels, beam soffits, soffit lengths, and corner components - into Revit family instances placed directly in the user's file. The API boundary is never crossed during solving - a disciplined engineering approach and design philosophy.
Algorithmic Solving (Guillotine Cuts)
To tackle the layout optimization, we implemented a Guillotine Cut Algorithm.
- Wayfinding: The solver treats the ceiling as a navigation grid (20mm × 20mm), analyzing edge and corner conditions to "map" the space.
- Bin Partitioning: It strategically slices the irregular ceiling profile into rectangular "bins" that can be efficiently packed with standard panels.
- Anchor Points: Every layout is set out from an anchor point, which must sit in a convex corner of the deck. The software offers the user only valid anchor locations; a top-left anchor, for example, yields a top-to-bottom, left-to-right layout with the non-standard balance panels pushed to the bottom and right edges.
- Rotation Strategies: Each bin adopts one of three packing behaviors: standard bins pack panels along the X-axis with a beam soffit at the base; short bins - where length falls within the maximum panel width - rotate panels 90° and need no beam; and bins that span the room from soffit to soffit pack panels edge-to-edge for maximum efficiency.
- Structural Logic: Thanks to the guillotine cut, every bin is always one panel length high plus the beam width, and beneath each bin the algorithm inserts a 100mm-wide row of beam soffits - the components that include the prop heads for the support props holding the deck while concrete is poured - ensuring the layout isn't just geometrically efficient, but structurally sound.
- Perimeter Packing: Around the perimeter edges, the solver switches to linear packing - placing soffit lengths (SL components) along each edge and resolving the soffit corner components (SC, typically 400mm x 400mm arm lengths) that complete the layout.
The solver's scope covers every horizontal condition in the model: flat decks, the horizontal surfaces of projections, drop slabs, slab folds, RC lofts, and beam kinks - resolving the deck and soffit components each condition demands.
Enterprise Features
Beyond the solver core, the tool handles the client's operational workflows.
- Inventory Management: The tool accepts Excel-based inventory lists of previously purchased formwork, allocating panels from that existing stock until it is exhausted before "ordering" new components.
- Dimension Overrides: Users can override standard panel sizes with custom dimensions directly from the UI - for example, substituting a custom width for the default 600mm panel width.
- Strategy Pattern: The rule engine uses the Strategy Pattern with design rules defined in external JSON and built dynamically at runtime—as the solver analyzes each geometric condition in the deck (surface, edge, or corner), it layers on the specific rule for that condition, applying over 1,000 distinct rules governing panel sizes, slab thickness, beam sections, and corner conditions.
UX & State Persistence
To ensure the tool was production-ready, we wrapped the complex backend in a modern WPF interface styled with Material Design.
- Visual Feedback Loop: An embedded Rhino viewport renders a live 3D view of the merged shell model — the cleaned, unified concrete geometry extracted from the architect's Revit model — providing immediate visual correlation between each ceiling selected in the UI and its physical spatial context. The solved formwork itself is placed directly in Revit.
- Performance Caching: The merged shell model is cached to make repeat solver runs significantly faster, and user inputs - overrides and options set in the UI - are cached per project, so nothing needs re-entering between runs.
- Smart State Management: We implemented a JSON-based caching system that tracks every element created by the solver. When a user re-runs a solution, the tool deserializes this state to "re-attach" to existing families, deleting only the stale elements before placing the new design. This ensures a clean file state and prevents duplicate geometry, even after the session is closed.
The application follows a satellite-service architecture: seven interdependent services with coordinated startup, restart, and shutdown lifecycles, wired through Autofac dependency injection behind 70+ interface contracts in the core library. The codebase adheres to SOLID principles and dual-targets .NET 4.8 and .NET 8.0 from a single source.
The Result
The Deck Solver transformed a manual engineering task that ranged from an hour to days into an operation completed in under 15 seconds.
- Geometric Freedom: By bypassing Revit's API limitations, the tool can solve any rectilinear shape, no matter how complex the voids or junctions.
- 1:1 Output: The output matches what the design team produces manually, 1:1, with the placement rules governing roughly 100 deck component types codified in the solver.
- Productivity: Users can rapidly optioneer design solutions - changing anchor points or beam directions from the UI - with each alternative solved in seconds in pursuit of the most efficient layout.
- Single-Click Workflow: Users select the ceilings to solve from a list derived from Revit Room elements, click Solve, and see the completed formwork solution in their Revit file in under 15 seconds - no setup, no drafting.
- Maintainable by Design: Refactoring geometry operations from the Revit API to RhinoCommon cut source lines of code by 10–30%, replaced 15+ line geometry workarounds with single RhinoCommon calls, and left a SOLID, Revit-API-decoupled codebase that is unit-testable without a third-party add-in — reducing development time and lifetime maintenance cost.
The Deck Solver is one of three tools in the formwork automation suite we delivered for this client. Its companion, the Wall Solver, applies the same headless Rhino.Inside architecture to vertical formwork, resolving component packing and wall-tie alignment across opposing wall faces, while the Model Error Checker acts as the suite's quality gate — validating the merged shell model both solvers consume before a solve is run.
- 10–30%
- Reduction in Codebase Size (vs Native API)
- <15s
- Solve Time (vs Hours–Days Manual)
- 1,000+
- Formwork Design Rules Codified
- 100%
- Traceability to Source Revit Elements