BIMVAR
A VR collaboration and clash-detection tool for architecture and construction, built during the Seattle VR Hackathon.
BIMVAR was a VR collaboration and clash-detection prototype for architecture and construction, created during the Seattle VR Hackathon.
The project explored how architects, engineers, contractors, and BIM specialists might inspect complex building models together in virtual reality. The goal was to make it easier to identify spatial conflicts, discuss them, and move through a large model without relying only on flat screens or disconnected review tools.
The prototype focused on Building Information Modeling, or BIM, and the problem of clash detection. In large commercial projects, many teams contribute separate models for plumbing, HVAC, electrical systems, structural elements, and other building systems. When those models overlap in unintended ways, the result can be expensive delays, rework, and coordination problems during construction.
I worked as a UX designer and became the de facto Unity lead for the project. My contributions included:
- Helping define the product concept and core user workflows
- Setting up and managing the Unity master scene
- Importing and scaling architectural model content
- Creating and integrating 3D interface elements
- Designing spatial menus, navigation tools, and collaboration markers
- Modeling interface components and prototype assets
- Troubleshooting Unity, Windows, plugins, VR hardware, and firmware issues
- Working with teammates to integrate code and features into the main build
- Helping implement voice commands using Amazon Alexa hardware
- Supporting demos and later presenting the project publicly
I was not a formal software engineer, but I had enough technical fluency to keep the prototype moving, troubleshoot issues, and work closely with teammates who had stronger coding experience when custom C# behavior was needed.
The team had two days to create a compelling VR prototype for a complex professional workflow. Most of us were new to Unity and VR development, and the HTC Vive had only been released weeks earlier.
The challenge was not just to put an architectural model into VR. We needed to explore how people might move through the model, identify clash points, communicate with collaborators, simplify visual complexity, and understand where they were in the building.
We also wanted to explore multi-user collaboration across VR and AR devices, even though the hackathon timeline made a full cross-device system unrealistic.
The project started with the real problem of clash detection in large building projects. Different vendors and disciplines often produce separate models that need to fit together physically. Plumbing, HVAC, electrical, structural, and other systems can conflict in ways that are hard to understand through drawings or isolated model views. Finding these problems before construction matters because each unresolved clash can lead to delays, redesign, labor costs, and installation conflicts.
We began by searching for architectural model content we could use publicly. Once we found usable content, I focused on importing it into Unity and matching the scale of architectural models, downloaded assets, and objects created in 3D tools. Scale was an early and important problem. Architecture tools and Unity do not always handle units and model structure in the same way, so we needed a practical process for making imported content feel consistent and usable in VR.
Once we had content in the scene, we started designing ways to move through it. One method used a controller-based laser pointer. A user could aim at a node in the model and move to that location, with a short fade transition to reduce disorientation. A second method used a controller-based list: bring up a list of points or clash locations, select one, and move directly there. We also discussed a third method based on separating the model into floors, though that concept was not built during the hackathon.
The prototype included collaboration concepts for pointing, notes, and shared discussion. We created a 3D pointer that could be placed in space so collaborators could indicate exactly what they were discussing. We also explored sticky notes that could hold audio or text information at a specific point in the model, combined with a pointer component that stayed locked to the item being referenced.
At one point during the hackathon, someone from Amazon brought Alexa hardware to the event. Another teammate and I used it to create voice commands for hiding and showing layers of the 3D model. A user could say a command to hide a mechanical layer instead of opening a menu, finding the right control, and closing it again. The same show and hide behavior was connected to both the voice interface and the menu interface, so we did not need to build separate systems for each control method.
As sub-teams finished features, I helped bring their work into the main Unity scene. Sometimes that meant copying over code, troubleshooting conflicts, fixing broken elements, or working with a teammate to translate the interaction we wanted into C# behavior. The process was messy but productive. We kept balancing ambition, technical feasibility, and demo readiness.
The project was grounded in a real architectural coordination problem. VR mattered because the work was spatial, not because it was new.
Floating menus can work in VR, but for this project some controls made more sense as a controller-attached interface, almost like a virtual tablet. This gave users a stable place to access lists, notes, and navigation options.
Moving through a large model can be disorienting. We explored multiple navigation patterns so users could move by pointing in space or selecting from a list of known points.
Voice commands were useful for actions like hiding and showing layers because they reduced the interaction cost of manipulating a dense model.
Pointers and notes needed to live in the model, not in a separate document. The more the comments stayed tied to physical locations, the more useful they became for collaboration.
VR hackathon and product footage from the Seattle VR Hackathon demo.
The BIMVAR demo was well received at the Seattle VR Hackathon. People with architecture, construction, and engineering experience immediately understood the potential value of reviewing building models in VR. Several people asked whether the software was available to purchase, which showed that the concept resonated beyond the hackathon setting.
A few members of the team, including me, continued exploring the project after the event. I presented BIMVAR at the 2016 Immerse conference, where we showed the demo alongside established VR companies. We also demonstrated the project at a Seattle VR Meetup.
The response showed that the project was doing more than showing a technical demo. It made a practical use case visible: VR could support design review, spatial coordination, and decision-making around physical things before they were built.
BIMVAR was a chance to apply ideas I already cared about: spatial computing as a practical design and decision-making tool, not only an entertainment medium.
That was one of the most rewarding parts of the project. Many people came to the hackathon expecting games or novelty demos. BIMVAR gave them a concrete example of another direction for the medium.
The project demonstrated the value of technical fluency in design work. I am not a software engineer, but I could set up scenes, troubleshoot the hardware and Unity environment, integrate assets, work through plugins, and collaborate with coders to get the interaction behavior we needed.