What is a GUID?
Every object in an IFC model is assigned a Globally Unique Identifier (GUID). You can think of it as the object's ID card.
No two objects in the same IFC model should have the same GUID.
Suppose you delete a beam in your BIM software and immediately create a new beam with exactly the same location, dimensions, material, and section. Although the new beam looks identical, it is considered a new object and therefore receives a different GUID.
Why does IFC version comparison rely on GUID?
For version comparison, GUID is an excellent identifier.
Imagine you move a beam by 300 mm, change its section size, or extend its length. Although the beam has been modified, its GUID usually remains unchanged because it is still considered the same object.
This allows comparison software to quickly locate the corresponding member in both IFC files before checking what has changed, such as:
- Section size
- Member length
- Position and rotation
- Material and other properties
If a GUID exists in the old model but cannot be found in the new one, the software can classify the member as deleted. If a new GUID appears only in the latest model, it can be classified as newly created.
As long as both IFC files originate from the same model history, this is an efficient and highly reliable comparison strategy.
Why does GUID fail when comparing models from different BIM software?
The challenge begins when models are created in different software.
A common structural design workflow might involve ETABS or SAP2000 for structural analysis, while Revit is used to produce construction drawings. An architect may develop the architectural model in Revit or Archicad.
Although these models describe the same building, they are created independently.
Each software environment creates its own digital objects and therefore its own GUIDs. Two beams representing exactly the same physical structural member may have completely different identities.
From the perspective of a traditional GUID-based comparison process, they are simply unrelated objects.
This is why a cross-software comparison may report that every member was deleted and every member was newly added, even though the two models visibly describe the same structure.
Why doesn't every BIM software preserve the same GUID?
GUIDs belong to the digital objects created within each software environment.
Even if two engineers independently model the same beam with identical dimensions, they are still creating two separate objects. Because there is no shared editing history between them, there is no reason for the software to assign the same GUID.
This is fundamentally different from comparing two versions of the same model, where object identity and editing history can be preserved.
Why does cross-software comparison require geometry matching?
Once GUID can no longer be used, another question naturally follows:
How do we determine which beam in Model A corresponds to which beam in Model B?
Interestingly, this is similar to how engineers perform manual checks.
When we open two models side by side, we do not compare GUIDs. We look at the building itself. We identify corresponding members based on their geometry, location, orientation, and surrounding context before checking whether their section sizes, elevations, lengths, or positions are consistent.
Cross-software comparison follows the same general idea. Instead of relying on object identity, the process first needs to determine which members most likely represent the same physical element before any meaningful comparison can begin.
Why are many structural model comparisons still performed manually?
Throughout my work as a structural engineer, I have mainly relied on two approaches.
Method 1 — Overlaying CAD drawings
Structural and architectural drawings can be overlaid using external references. This works reasonably well for simple projects, but discrepancies are easy to miss when multiple elevations, numerous revisions, or many steel section types are involved.
Method 2 — Side-by-side model review
An analysis model such as ETABS can be opened on one screen and a BIM model such as Revit on another. The models are then checked floor by floor and member by member. It is more direct, but repetitive and mentally exhausting.
Why I started building StructMatch
These workflows eventually led me to a simple question:
What if structural models could be compared the same way engineers compare them manually?
Instead of relying on GUIDs, what if software could first identify corresponding structural members based on their geometry and then automatically highlight differences in section size, length, position, elevation, or orientation?
That idea became the starting point of StructMatch.
Rather than replacing engineering judgment, the goal is to automate one of the most repetitive parts of structural coordination—allowing engineers to spend less time searching for differences and more time evaluating them.