Exodus

Inspiration

In an emergency, getting out of a building should be simple: find the safest exit and follow it. In reality, indoor navigation breaks down exactly when people need it most. GPS is unreliable indoors, floor plans can be confusing, exits may be blocked, and conditions can change while someone is evacuating.

We built Exodus to explore a better approach: an indoor emergency navigation system that understands where a user is, understands the building around them, and gives them an augmented-reality route to safety.

Our goal was to combine computer vision, AR, mapping, and deterministic routing into something that feels intuitive in a stressful situation. Instead of staring at a 2D floor plan, a user can hold up their phone and follow navigation directly through the physical environment.

What it does

Exodus lets a building be mapped once and then used for indoor navigation.

The system represents the building as a navigable graph of hallways, intersections, rooms, and exits. When a user begins navigation, Exodus calculates a route using a deterministic shortest-path system and displays that route directly in the camera using AR.

But indoor navigation is more difficult than simply drawing arrows.

Exodus also uses computer vision to understand what the camera sees. Apple Vision is used for tasks such as EXIT-text recognition and human detection, while additional semantic detection can recognize objects such as barricades, traffic cones, barriers, and blocked doorways.

Detections are temporally tracked so objects do not permanently remain on the screen after they disappear. If Exodus determines that a persistent obstruction is relevant to the current route, it can warn the user and use the existing building graph to calculate an alternate path rather than allowing AI to directly invent a route.

We also developed a learned visual localization pipeline. During mapping, Exodus captures selected camera keyframes along with ARKit camera poses and calibration information. Those images can be turned into a visual reference map using pretrained computer-vision models and structure-from-motion. Later, a camera image can be matched against that reference map to help correct accumulated ARKit positioning error.

For building administrators, Exodus also includes tools for managing building maps, visualizing spatial data, and georeferencing indoor maps against real-world building locations.

How we built it

The iOS application is written primarily in Swift and SwiftUI.

We use ARKit for visual-inertial tracking and RealityKit for rendering navigation guidance in augmented reality. The building itself is represented as a deterministic graph, and route calculation remains separate from the machine-learning systems. This was an important design decision: AI can provide observations about the environment, but the routing system remains predictable and testable.

For localization, we built a sensor-fusion pipeline that combines ARKit movement estimates with external visual observations. A Kalman-filter-based localization system accepts useful measurements while rejecting measurements that are stale or inconsistent.

Our learned visual mapping pipeline uses established computer-vision techniques rather than training a new model for every building. It combines technologies such as DISK, LightGlue, MegaLoc, hloc, and COLMAP/PyCOLMAP to create reference features and 3D structure from mapped images.

For semantic understanding, we use Apple Vision locally where possible and a lightweight FastAPI service for additional vision-model inference. The app tracks detections across frames, associates relevant observations with the current navigation route, and removes stale detections automatically.

The backend is built around Supabase/PostgreSQL, and our administrative tools include building metadata, navigation-map management, spatial visualization, and geographic alignment. We also incorporated MapLibre and OpenStreetMap data to place indoor maps into a broader real-world building context.

Challenges we faced

The hardest problem was localization.

ARKit is extremely useful for tracking movement, but small amounts of drift become meaningful when navigation depends on knowing which hallway or intersection someone is standing in. We therefore had to build our system so that visual localization could correct the position estimate without allowing a slow or unreliable ML result to destabilize navigation.

Performance was another major challenge. Some of our first visual-mapping experiments ran feature extraction on the CPU and took roughly 35 seconds per image. By correctly using Apple's GPU through Metal Performance Shaders, we reduced that stage to well under one second per image on our development hardware.

We also discovered how easy it is for different subsystems to interfere with each other. Mapping tools, localization experiments, AR navigation, semantic detection, and routing all use overlapping camera and spatial state. Keeping those systems isolated while maintaining a working end-to-end application required extensive debugging and regression testing.

Another challenge was deciding where AI should—and should not—be trusted. A vision model may say that it sees a barricade, but that does not mean it should be allowed to permanently modify a building map or independently decide an evacuation route. We designed Exodus so perception provides evidence, while deterministic navigation remains authoritative.

What we learned

The biggest thing we learned is that a strong spatial-AI product is not one giant AI model.

Exodus works by combining several specialized systems: ARKit tracks motion, computer vision understands camera frames, visual localization corrects drift, a building graph describes valid movement, and a deterministic routing algorithm decides where the user should go.

We also learned that building a technically impressive prototype is very different from building a reliable real-time system. Latency, stale measurements, coordinate systems, temporary detections, failure cases, and device limitations matter just as much as model accuracy.

Most importantly, we learned that AI is often most useful when it improves the information available to a reliable system rather than replacing that system entirely.

What's next

Our next goal is to make the entire mapping pipeline automatic: an administrator should be able to walk through a building once, press Finish Mapping, and have Exodus automatically construct and upload everything required for navigation.

We also want to continue improving real-time visual localization, dynamic obstruction awareness, building-scale 3D visualization, and physical-device testing across larger and more complex indoor environments.

Ultimately, we want Exodus to make indoor emergency navigation feel as natural as following directions on a map—except the directions appear directly in the world around you.

Built With

• ai
• apple
• arkit
• colmap
• core
• disk
• fastapi
• featherless
• hloc
• ios
• lightglue
• maplibre
• megaloc
• ml
• openstreetmap
• postgresql
• pycolmap
• python
• pytorch
• realitykit
• supabase
• swift
• swiftui
• vision
• xcode