Stomra Guides

OpenEik · Guide

OpenEik and IFC

IFC is the shared print of a finished model; OpenEik is the source you keep editing. How the two fit together, and where IFCX, the next IFC, comes in.

IFC: ONE WINDOW, FOLLOWED BY NUMBER #4711 IfcWindow placement: see #9182 #9182 IfcLocalPlacement relative to #233 #233 IfcWall placed relative to #87 #87 IfcBuildingStorey placed relative to #12 #12 IfcBuilding and so on, upwards #5120 IfcOpening… the hole: a box of its own #6001 IfcRelVoids… #5120 cuts #233 #6002 IfcRelFills… #4711 fills #5120 Numbers made up; a real file renumbers them when it is written again. OPENEIK: ONE FILE THAT SAYS WHAT IT IS …/window/study-window-east.json { "along": 1100, "category": "window", "height": 1500, "hostId": "study-wall-1", "id": "study-window-east", "offset": 900, "typeId": "type-window", "width": 1800 } The engine cuts the hole and places the window.
The same window two ways. In IFC it is a chain of numbered entities: a placement relative to the wall, a separate opening, and relations that tie them. In OpenEik it is one file that names its wall, its position along it and its sill height.

IFC is a print of the building

IFC, the Industry Foundation Classes of buildingSMART (ISO 16739), is how building models move between programs. It was designed to carry the output of every BIM program, each with its own internal rules. The one thing all of them share is the result, so that is what IFC stores: finished shapes, where they sit, what they are called and the properties attached to them.

That makes an IFC file much like a PDF. Make a PDF from a word processor, a calculation sheet or a drawing program, and it looks exactly right anywhere. But it holds lines and letters: the formula in the calculation sheet is gone, and changing a number recalculates nothing. An IFC file exported from any BIM program likewise opens anywhere and looks right. But the wall is a finished solid. "From here to there, attached to the roof" is gone, so making it longer moves nothing else.

A print is the right thing for handing a finished model over, for checking it in another program and for keeping it on record. That is what IFC does well, and it is why procurement asks for it. It is a harder place to keep changing a building, and that is the job OpenEik is made for.

Why IFC is hard to edit

Take the window in the picture above and make it 200 mm wider. In an IFC file that means:

  1. Find every piece. The window is one entity among thousands. Its position, its shape, its opening and its properties are separate entities, linked by number. Following the chain is the first job.
  2. Change the shape and the hole. The opening in the wall is its own box. Widen the window and the hole does not follow; it has to be changed in step.
  3. Nothing adjusts itself. Shapes are stored as finished geometry, not as ideas. The file says "a box with these corner points", not "a wall from here to there, 200 mm thick".
  4. Keep every link right. If one reference points to the wrong number, the building breaks without a warning. A file can be valid and still describe a wrong building.

Then there is following a change. The entity numbers mean nothing about the building; a program hands them out when it writes the file, and may hand out new ones on every export. Compare two exports and nearly every line looks different. Liu, Gao and Gu found 18,659 changed lines between two exports of the same, unchanged model, and 99 % of a file rewritten after five objects were removed and five added (EG-ICE 2023, arXiv:2312.14931). The ordinary tools for following change, a diff, a search and a review of the lines that changed, have little to hold on to.

AI agents meet the same difficulty. The numbers fill their working memory with bookkeeping, and an edit has to change entities far apart in the file exactly in step, with nothing checking the work.

What OpenEik stores instead

OpenEik keeps the intent. A window is one small file in a sensible folder: in which wall, how far along it, at what sill height, of which type. An engine derives the shape, cuts the hole, makes the joints and counts the quantities, every time, from those few values.

architecture/level-0/window/study-window-east.json
-  "along": 1100,
+  "along": 1600,
-  "revision": 2,
+  "revision": 3,

Moving the window 500 mm along its wall is that diff: its position and its revision, in one file named after the window. Every change is a command checked against the whole model before it is saved, and every record keeps its id for its whole life. The same move in an IFC export of the example L-house changes more than half of the file's lines, nearly all of them only renumbered; openeik.org/why shows that measurement. The Buildings as code guide explains the folder, versions and merges in full.

The same windowIn an IFC fileIn OpenEik
Where is it?Follow the references from entity to entityarchitecture/level-0/window/study-window-east.json
What does it say?A finished shape, a separate opening and the relations that tie themWhat it is: in wall study-wall-1, 1,800 mm wide, sill at 900 mm
Make it widerEdit the shape and the opening, keep every reference rightChange its type or width; the engine cuts the new hole
Is it right?A valid file can still hold a wrong buildingChecked against the whole model before it is saved
What changed?Compare two whole filesThe lines of one file

What OpenEik keeps from IFC

OpenEik is built on what IFC got right, and changes how the model is kept.

Keeps: meaning

A wall is a wall and a door is a door, each on its level, not a heap of shapes.

Keeps: types

Elements share a type that sets their layers, sections and sizes.

Keeps: properties

Data rides on the element it describes.

Keeps: neutrality

No program owns the model, and any program can read it.

Changes: intent

Records say what a thing is; shapes, holes, joints and quantities are derived.

Changes: names, not numbers

Every record keeps its readable id for its whole life.

Changes: one record per file

A change touches only what it changes, so it can be read and reviewed.

Changes: versions

History, alternatives and merges, as a code base has.

Printing IFC from OpenEik

An OpenEik building prints IFC whenever it needs to go to a program that reads IFC, and the print follows clear rules:

OpenEik version the source: records, history IFC4 · IFC 4.3 print for exchange IFCX experimental print PDF drawings print for people An IFC file from another program read once, to start a project
OpenEik is the source. IFC, IFCX and PDF are prints of one version. An IFC file from elsewhere starts a new OpenEik project.

A print is never the record. Two IFC prints are not compared to find what changed; the versions they came from are. Reviews, sign-offs and issues are about versions, never about a print.

On EikHub, an IFC is printed this way from the version you are looking at.

Starting from an IFC file

OpenEik can also read IFC, to start a project from a model made in another program. The reading is deterministic: the same file always gives the same records and bodies.

Reading is a start, not a live link. A later delivery of the same IFC file is read as a new start; changes from then on are made in OpenEik and printed back to IFC.

IFC 5, now IFCX

buildingSMART is working on the next IFC. It was called IFC 5 and has since been renamed IFC X, written IFCX. Its published format is an alpha and will change as the work goes on.

An IFCX file is JSON. It holds nodes named by paths, and each node carries namespaced components, such as bsi::ifc::class for its class, bsi::ifc::prop::… for properties and a mesh for its shape. Files can be stacked as layers: a second party writes a layer over the first, and where two layers say something about the same path, the later one wins.

Shared aims

IFCX and OpenEik start from the same observations about today's IFC:

JSON, not STEP

Readable by any tool, and comparable as text.

Relations as fields

No separate relationship entities to keep in step.

Deltas

Send what changed, not the whole file.

Shared work

Several parties contribute to one building.

Where they differ

IFCX (alpha)OpenEik
Shape of the dataOne file, or a stack of layer filesOne record per file in a folder
IdentityA path; objects from IFC4 keep their GlobalId as the pathA readable id kept for life; the GlobalId derived from it when printing
GeometryStored meshes and placementsIntent stored; bodies derived by the engine
ChangeLayers composed in order, the later one winningChecked commands; versions; merges by record and field, with conflicts reported
ClassesNamed by buildingSMART Data Dictionary (bSDD) URIsTyped categories; a classification can name its code by a URI, such as a bSDD URI

Where IFCX is strong

OpenEik's IFCX print

Because IFCX is a format for exchange, OpenEik treats it the way it treats IFC4: as a print of a version, never as the record. The OpenEik tools can print a building as IFCX, experimentally, from the same objects as the IFC4 print: each node's path is the object's GlobalId written as a UUID, as buildingSMART's own converter writes it, with the same classes, property sets and bodies, in metres. The print follows buildingSMART's alpha and changes with it.

Which to use when

You want toUse
Design and change the building, alone or with others and their agentsOpenEik, with its versions, alternatives and reviews
Hand a model to a program that reads IFC, or deliver it to a clientAn IFC4 or IFC 4.3 print of a version
Start from a model made in another programRead its IFC once into a new OpenEik project
Try IFCX in buildingSMART's toolsThe experimental IFCX print
Find out what changed between two deliveriesCompare the OpenEik versions, not the prints

The full rules for printing and reading IFC are in the bridges part of the OpenEik specification at openeik.org.