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 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:
- 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.
- 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.
- 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".
- 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 window | In an IFC file | In OpenEik |
|---|---|---|
| Where is it? | Follow the references from entity to entity | architecture/level-0/window/study-window-east.json |
| What does it say? | A finished shape, a separate opening and the relations that tie them | What it is: in wall study-wall-1, 1,800 mm wide, sill at 900 mm |
| Make it wider | Edit the shape and the opening, keep every reference right | Change its type or width; the engine cuts the new hole |
| Is it right? | A valid file can still hold a wrong building | Checked against the whole model before it is saved |
| What changed? | Compare two whole files | The 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:
- Everything with a body. Every element that has a body is printed, with its type, its level as a building storey, and its doors' and windows' openings as voids in their walls.
- IFC4 and IFC 4.3. The print is IFC4 unless IFC 4.3 is asked for, with swept solids for profiled members, material layer sets for layered types, element types and property sets.
- A fidelity report. Every print comes with a report of the schema written, the counts of products, openings and types, and what the print leaves out or approximates. A short form travels inside the file.
- GlobalIds that stay. Each object's GlobalId is derived from the project's id and the record's id. Print the same building again, a year later or from an alternative, and the same wall has the same GlobalId, so a model checked in another program can be compared with a later one. An element read from IFC keeps the GlobalId it came with.
- It says it is a print. The file names the version it was printed from and who printed it, and carries a sentence saying that it is a copy and that the OpenEik building is the source.
- The same bytes every time. The same version printed with the same options gives the same file, with no changing time stamp or numbering.
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.
- Each building storey becomes a level, each type a type, each space a room.
- Walls, beams, columns, slabs, foundations, roofs, railings and electrical devices are recognised and become records of their own kind. Doors and windows are hosted by the wall whose opening they fill.
- An element of any other class becomes a generic element that keeps the shape the file draws, its class and its property sets, so nothing is lost. A person or an assistant can turn it into a proper record later.
- IFC4 and IFC 4.3 files are read.
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 data | One file, or a stack of layer files | One record per file in a folder |
| Identity | A path; objects from IFC4 keep their GlobalId as the path | A readable id kept for life; the GlobalId derived from it when printing |
| Geometry | Stored meshes and placements | Intent stored; bodies derived by the engine |
| Change | Layers composed in order, the later one winning | Checked commands; versions; merges by record and field, with conflicts reported |
| Classes | Named by buildingSMART Data Dictionary (bSDD) URIs | Typed categories; a classification can name its code by a URI, such as a bSDD URI |
Where IFCX is strong
- Backing. buildingSMART and the major software vendors stand behind it, with a path into ISO.
- Reach. It covers every domain IFC covers, infrastructure included.
- An open vocabulary. A firm or an authority can publish its own namespace, with meaning kept in bSDD dictionaries.
- Federation and continuity. Files from different firms compose in the reader, and IFC4's classes and GlobalIds carry straight over.
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 to | Use |
|---|---|
| Design and change the building, alone or with others and their agents | OpenEik, with its versions, alternatives and reviews |
| Hand a model to a program that reads IFC, or deliver it to a client | An IFC4 or IFC 4.3 print of a version |
| Start from a model made in another program | Read its IFC once into a new OpenEik project |
| Try IFCX in buildingSMART's tools | The experimental IFCX print |
| Find out what changed between two deliveries | Compare 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.