From BIM to Web-Ready 3D: the Essentials

We show how heavy architectural models can feel fast on the web without gutting visual quality. The crux is smarter export plus targeted optimization: start with a Revit or IFC path that fits your goal, then apply compression and scene hygiene. Revit plug-ins are great for quick delivery and decent materials; pipelines around IFC or a DCC tool unlock chunking, instancing, and reliable metadata. We regularly combine Draco or meshopt for geometry and KTX2 for textures, aiming for sub-100 MB GLB and stable 60 FPS on mid-range machines.

What usually hurts is not just triangles but draw calls, transparency, and missing instancing. We fix that upfront: preserve repeated families as instances, split scenes by floor or 10 m cells for streaming, and bake only a small, known material set (glass, metals, concrete, wood) to keep things predictable. A simple edge-score decimator helps us protect doors, stairs, and life-safety details while simplifying slabs and ductwork aggressively.

In a recent retrofit viewer for a small heritage center, a “one-click” export landed at 68 MB but struggled with glass sorting; the IFC pipeline, finished with meshopt and KTX2, reached 41 MB, halved draw calls, and streamed cleanly to phones. That’s the pattern: quick wins from plug-ins, deeper gains from pipelines, and a little custom glue where it counts. If you’re deciding, export a single floor both ways, measure GLB size, draw calls, and median FPS — let the numbers choose the path.

Common Questions

Q: Plug-in or pipeline: how do we choose? A: If we need a fast demo from a curated Revit view, we start with a Revit-to-glTF plug-in. For public web or VR at scale (streaming, instancing, reliable metadata), an IFC or connector pipeline wins. We often baseline with the plug-in, then graduate to a pipeline for production.

Q: What are the minimum metrics to compare exports? A: GLB size (MB), draw calls, and median FPS on a mid-range laptop. One floor, exported two ways, tells the story faster than feature lists.

Q: Why not just decimate triangles and call it a day? A: Because BIM pain is usually draw calls, transparency, and duplicated parts. A 1.5M-tri model at ~800 calls often outperforms an 800k-tri model at ~3k calls. We prioritize instancing, material consolidation, and glass sorting first; decimation comes after.

Q: Which compression stack is the safest default? A: Draco or meshopt for geometry, KTX2 for textures. Typical mesh savings are 5–10x and textures 2–4x once normals/UVs are deduplicated. If the exporter lacks meshopt, we post-process the GLB — still excellent results.

Q: Can we keep critical detail while simplifying the rest? A: Yes. Our decimator scores edges: score = w1edge_length + w2boundary_flag + w3*category_weight. Doors, stairs, fire systems get higher weights; slabs/duct runs get lower. Low-score edges collapse first, preserving readability where it matters.

Q: How do we make big buildings stream smoothly on phones? A: Split by floor and a simple 10 m grid, normalize to meters and Z-up, and ship per-cell bounds. The viewer fetches only cells inside the frustum plus a small halo — often 60–80 percent less bandwidth than a monolithic GLB.

Q: What common snags should we check on the very first export? A: Units/origin drift, loss of instancing (repeated families becoming duplicates), glass rendering order, oversized or redundant textures, and material bloat. Fixing these early prevents late firefighting.

Q: What tradeoffs did a recent niche client accept to hit performance? A: We baked a single glass material, added room-level LODs, and chunked by floor. Result: smoother camera motion and a GLB in the ~40 MB range, versus a one-click export that looked similar at rest but stuttered during navigation.
Contact Elf.3D to explore how custom mesh processing algorithms might address your unique challenges. We approach every conversation with curiosity about your specific needs rather than generic solutions.

*Interested in discussing your mesh processing challenges? We'd be happy to explore possibilities together.*

BIM to Web 3D: a Practical Survey of Exporters and Pipelines

We keep meeting teams who want their Revit or IFC models to feel light and interactive on the web or in headsets, but the toolbox is noisy. Below is a brief, neutral survey of what’s out there and where each option shines (and slips). Our goal here is educational; we’ll end with a small field note from a niche client where we measured the impact of a modern pipeline.

What “lightweight” actually means

On phones and standalone headsets, bottlenecks aren’t just triangles. GLB size, texture resolution, material count, and draw calls all compete for the same budgets.

Two quick rules of thumb we use when scoping:

  • Triangle budget per view: about 2x the rendered pixel count is usually safe for static scenes with GPU instancing. For a 1920x1080 viewport, that’s ~4 million; we target 1–2 million for BIM because materials and transparency add overhead.
  • File-size budget for initial load: shoot for 20–80 MB GLB for “building walkthrough” fidelity, with a streaming plan for anything bigger. Draco or meshopt compression can drop storage by 5–10x on typical BIM geometry if normals/UVs are deduplicated first.

Those are starting points, not laws. The tools below help you approach these targets in different ways.

Revit-to-glTF exporters (plug-ins)

These run inside Revit and produce glTF/GLB directly. We grouped a few representative options; features and pricing change often, so consider this a snapshot for comparing directions, not an endorsement.

Tool License/Cost Compression & LOD Notes
DiRoots “glTF Exporter” Commercial, trial available Draco compression; export Active View/Selection; category filters Solid for web/VR handoff; straightforward UI; good when you want controlled scope (by view or category).
SimLab GLTF Exporter Commercial, trial available GLB/gltf output; strong materials handling; compression options vary by version Often praised for preserving materials; we’ve had to post-compress with meshopt/Draco when sizes were high.
EverseDevelopment Revit glTF Exporter (open source) Open source (MIT) Basic geometry export; community-driven Useful for simple viewers or as a baseline you can modify; expect to add your own compression/metadata steps.
Twinup / Community Revit2gltf (open source) Open source Basic export; hookable in custom workflows Handy if you need to embed export logic into a bespoke toolchain; less turnkey than commercial plugins.
Leia glTF Exporter / Visionworkplace GLTF Converter Commercial Feature sets vary; often GLB export with material support Worth testing on your models; look for transparency sorting and instancing behavior.

When these are a good fit: You want a one-button export from a curated 3D View, you’re OK with Revit’s tessellation as-is, and you don’t need deep restructuring of the scene graph. They excel at design reviews and quick web demos.

Where we still wrestle:

  • Transparency & sorting: Curtain walls and glass partitions can render in the wrong order; some exporters bake everything into one material pass, which looks off.
  • Instancing loss: Many exports duplicate repeated families instead of instancing, inflating draw calls and size.
  • Metadata mapping: BIM properties often emerge as ad-hoc JSON or are dropped; great for visuals, less great for data-driven interactions.

IFC-to-glTF and hub-based pipelines

If you can step outside Revit, more optimization knobs appear.

Path Strengths Limitations
IfcOpenShell (IfcConvert) → GLB Robust IFC geometry conversion; headless CLI; easy to automate IFC fidelity varies; category mapping and materials need tuning; may require post-decimation.
FME (Revit/IFC → glTF writer) Industrial ETL; can weld metadata, remap categories, split by floors/zones License cost; you still want a web-savvy post-process for size and draw-calls.
CAD Exchanger (IFC/Revit* → glTF) Clean glTF with assemblies and properties; supports both glTF and GLB Commercial; pipeline design still needed for LOD and streaming.
Connectors (e.g., Revit → Speckle → Blender/Three) Flexible: stream geometry, edit in Blender, export GLB with custom baking More moving parts; requires scripting to keep sizes small and properties consistent.

*Revit support may be via dedicated reader or IFC/other intermediates, depending on the product variant.

When these are a good fit: You want automation on a build server, structured metadata, or you need to split a campus-scale model into streamed tiles. They’re less “one click,” more “pipeline thinking.”

Typical snags we note:

  • Units and origin drift: IFC and game engines disagree about units/up-axis/origin. We normalize early: world-up Z, meter units, origin at project base point or shared datum.
  • Material baking: BIM materials don’t map 1:1 to PBR. We bake to albedo/metalness/roughness at the lowest texture resolution that still reads correctly in context (often 512 or 1024).

A tiny, real-worldish story

A small heritage center asked us to deploy a “walkable” model of a retrofit with layered MEP — classic heavy BIM. The Revit file had ~11 million triangles in a full 3D view, 260+ materials, and lots of glass. We trialed three paths:

1. Revit plug-in with Draco on

  • Result: 310 MB GLB → 68 MB after Draco; draw calls ~2.8k; FPS on a mid-range laptop in browser ~35–45.
  • Win: one click, decent material preservation.
  • Compromise: transparency sorting issues in atrium; repeated ducts were not instanced, pushing draw calls up.

2. IFC → IfcOpenShell → GLB, then meshopt + KTX2

  • Result: 245 MB GLB → 41 MB after meshopt; KTX2 basis for textures brought another ~30 percent savings; draw calls ~1.1k after we split by floor and instance common families.
  • Win: better streaming behavior; metadata attached as per-node extras.
  • Compromise: spent time rebuilding materials to PBR; a few parametric profiles triangulated noisily and needed remeshing.

3. Connector route (Revit → data hub → Blender → GLB)

  • Result: Visually best; we baked glass to a single sorted material group and packed lightmaps for key interiors; ~52 MB GLB, ~900 draw calls.
  • Win: artists took control of materials and generated room-level LODs.
  • Compromise: more steps to automate; occasional deltas when the BIM updated required re-bakes.

For their public web viewer we shipped path 2 with a fallback “low” mode: all MEP hidden beyond 10 m and stair handrails simplified. For kiosk VR we used path 3 — nicer materials and stricter LODs outweighed the extra bake time.

Why custom glue still matters

Generic exporters can’t know your interaction model. Two small examples where bespoke code outperformed defaults for us:

  • LOD by distance and purpose: We built a decimator that preserves edges classified as doors, stairs, and fire systems at a higher error budget. We score edges using a simple weighted sum: score = w1*edge_length + w2*boundary_flag + w3*category_weight. Edges with low score are first candidates for collapse. This kept egress routes crisp while letting big slabs drop triangles aggressively.
  • Spatial chunking for streaming: Instead of one GLB, we partitioned by floor x 10 m grid cells, snapped to a shared origin, and wrote a manifest with bounding boxes. The viewer only fetches cells intersecting the camera frustum plus a small halo, cutting bandwidth on mobile by 60–80 percent.

These aren’t fancy — just the kind of “from scratch” glue that fits the building and the audience. We’ve also learned where to stop: we once tried to auto-bake every Revit material into full PBR sets; we lost days for only marginal gains. Now we auto-bake a small material library (glass, metals, concrete, wood) and let anything unrecognized fall back to flat colors.

Choosing a path: quick decision matrix

Situation What we’d start with Why
Design review for stakeholders next week Revit plug-in with GLB, Draco on Fastest end-to-end; minimal setup.
Public web walkthrough on phones IFC → IfcOpenShell → meshopt + KTX2; chunk by floor/zone Better streaming and control over LOD/draw calls.
High-touch VR kiosk in a gallery Connector → DCC (Blender) → GLB with baked materials + LODs Artist control beats raw export for perceived quality.
Data-rich dashboards ETL (FME/CAD hub) → GLB + sidecar JSON Strong property mapping and repeatable automation.

Takeaways (and what to watch)

  • You can hit sub-100 MB, 60 FPS experiences from heavy BIM with smart conversion and chunking; the levers are compression, instancing, and selective LOD, not just triangle counts.
  • Revit plug-ins are great for quick wins; pipelines around IFC or connectors unlock scale, streaming, and metadata quality.
  • Expect some compromises: glass sorting, instancing fidelity, and material baking are the usual troublemakers.
  • A little custom code around decimation, chunking, and property mapping often beats any “one size fits all” framework for unconventional models.

If you’re evaluating options, we’d start by exporting a single floor twice — once via a plug-in and once via a pipeline — and measure three numbers side by side: GLB size (MB), draw calls (count in viewer), and median FPS on a mid-range laptop. That mini-bake-off tells you more, faster, than a month of feature lists. And if something odd shows up — say, a stair handrail with 200k triangles — well, that’s where we like to roll up sleeves.