> ## Documentation Index
> Fetch the complete documentation index at: https://docs.gingerbim.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Modelling Guidelines

> How to structure your Rhino or SketchUp model so every element lands in the right component bucket.

The connector sends your model through **component buckets**, and each bucket accepts specific kinds of geometry. Rhino and SketchUp structure object data quite differently, so the rules are different in each tool — find your section below. The [acceptance table](#geometry-acceptance-by-component) at the end summarises both.

In both tools: model in real-world units at real-world size, and purge unused geometry before sending. If the connector warns that an object carries an unusually large number of faces, see [Simplifying Heavy Geometry](/connectors/simplifying-heavy-geometry).

## Rhino

**Solid elements — Wall, Slab, Beam, Column, Ramp, Finishes, Opening.** Model these as **closed polysurfaces, extrusions, or closed meshes**. Open surfaces are rejected with a warning ("does not support open surfaces") — cap your geometry so it's watertight.

**Compound elements — Door, Window, Stair, Railing, Lift.** Model these as **blocks or groups**, so each door or stair arrives as one element. Use block definitions for repeated elements — instances are far more efficient. (Roof is flexible: block, group, or a closed solid all work.)

**Curves and lines are for Site Parameters only.** Lines and polylines go in the **Site Parameters** bucket — as Gridlines, the Site Boundary, or Setbacks. No other bucket accepts curve geometry, so 2D linework elsewhere in the model won't send.

**Groups.** You can group solid elements (walls, slabs, beams, columns, finishes) for your own organisation and still send them — but the grouping itself isn't kept: they arrive in GingerBIM as individual elements. One caution: a group whose members sit on layers that map to *different* categories can't be auto-categorised — keep a group's contents on consistent layers, or add it to a bucket manually.

**Organise with layers.** Name your layers after what they contain (`wall::RC`, `A-Window-Louvre`, `SLAB`) — the **Auto-categorise** button reads layer names and fills the buckets for you. See [Categorising Objects](/connectors/categorising-objects).

## SketchUp

**Solids are closed groups or components.** For solid elements (Wall, Slab, Beam, Column, Ramp, Finishes, Opening), the group or component must be a true solid: manifold, with a **single volume**. A group containing two or more separate solid bodies (a *disjoint* solid) is not accepted — split it so each element is its own solid.

**Use components for compound elements** — doors, windows, stairs, roofs, railings, lifts. A component arrives as one element: categorise it once, one schedule row, one drawing tag. Components are also SketchUp's mechanism for repetition, so identical doors stay identical.

**Non-solid groups are treated as informal organisation.** SketchUp users group things loosely all the time — that's fine, but the connector doesn't treat such a group as an element. On send, the group wrapper is dropped and its contents are evaluated individually. Don't rely on a loose group to represent a building element; make it a solid or a component instead.

**Loose faces and edges can't be published** as elements. Geometry that's just faces in a group can only go into the **Generic** bucket, where it's sent as a single mesh. If something should be a wall or a slab, make it a solid group/component first.

**Organise with tags.** Tag each group/component with what it is (`Wall::RC`, `window`, `FLOR`) and **Auto-categorise** sorts them into buckets from the tag names. An object's own tag is what counts; untagged objects fall back to the tag of the group that contains them. See [Categorising Objects](/connectors/categorising-objects).

## Openings for doors and windows

The **Opening** bucket holds placeholders for GingerBIM's door and window generator. Instead of modelling a finished door or window, you model the volume where one will go, and the generator uses it to place the door or window on the GingerBIM platform.

**Model one simple box per opening.** Make it the opening's width × height × the wall's thickness, square to its wall, with its bottom face at sill or threshold level. The generator reads the box's position, its orientation along the wall, and its width, height, and depth.

**Keep it a rectangular box.** GingerBIM replaces whatever you send with its bounding box — the generator only works with boxes. An arched opening or an oddly shaped solid simply ends up as its box, so model the box you want.

**Naming.** Put openings on their own layer or tag — `OPENING` or `A-Openings` — and Auto-categorise sorts them for you. Watch compound names: words are read left to right, so `WALL_OPENING` goes to Wall and `WINDOW_OPENING` to Window. See [Categorising Objects](/connectors/categorising-objects).

## Geometry acceptance by component

| Component | Rhino | SketchUp |
| - | - | - |
| Wall (Generic / Brick / RC / Block / Drywall) | Closed polysurface, extrusion, or closed mesh | Solid group or component |
| Slab · Beam · Column · Ramp | Closed polysurface, extrusion, or closed mesh | Solid group or component |
| Finishes (Wall / Floors / Ceilings) | Closed polysurface, extrusion, or closed mesh | Solid group or component |
| Opening | Closed polysurface, extrusion, or closed mesh | Solid group or component |
| Door · Window · Stair · Railing · Lift | Block or group | Component (or solid group) |
| Roof | Block, group, or closed solid | Component or solid |
| Site Parameters (Gridline / Site Boundary / Setback) | Line or polyline | Component or solid |
| Generic | Any geometry | Group, component, or solid (loose-face groups send as one mesh) |

<Tip>
  A "solid" means one watertight volume. In SketchUp, a group that reports as solid but contains two separate bodies still won't be accepted — one element, one volume.
</Tip>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.