Inspiration 💡

The physical world is the ultimate social network, but our digital tools treat it like a dead zone.

If you sit in a bustling university library, an airport lounge, or a 1,000-person hackathon, you are surrounded by potential co-founders, mentors, and friends. Yet the "Cold Start Problem" of human interaction is massive. The friction of initiating a conversation, spelling out a LinkedIn URL, or awkwardly fumbling with a QR code keeps us locked in our digital silos.

Current proximity tech is blind. Bluetooth and Apple AirDrop broadcast your device to anyone in radio range without any context, leading to digital spam and privacy concerns.

We wanted to invent a new social protocol based on Contextual Consent. We asked ourselves: What if we could bridge the physical-to-digital air gap seamlessly? What if the environment itself could facilitate the handshake? We realized that true connections require mutual, synchronized intent. That realization birthed Glance: Zero-Click Connections.

Why it's different ✨

Glance is not another chat app, messaging platform, or Uber-for-X.

Chat and messaging apps assume you already know the person. Glance is how you meet them in the first place.
Ride-share and marketplace apps are transactional. Glance is relational: two people, one shared moment.
Social feeds broadcast to everyone. Glance connects you to exactly one person, and only if you both signal.

The interface is not a screen you tap. It is your body and the objects around you: a thumbs up, a peace sign, a coffee cup. Any signal that matches becomes the handshake.

And it is real. The core loop runs live end to end: real webcam frames, real Gemini vision calls, real-time matching, and a real chat between two devices. The detection and the match are never mocked. You raise a signal and the viewfinder responds in real time, moving through IDLE → DETECTED → INTENT → VERIFYING → MATCH as it sees you.

What it does 🪄

Glance is an ambient intent-sensor that transforms your laptop into a spatial networking tool. It redefines how we establish digital connections by anchoring them to real-world physical context.

Instead of typing names or navigating dashboards, the Glance UI acts as a cinematic viewfinder. It sits quietly on your screen in a monochromatic, immersive "Scanning" state.

The Magic Interaction

The Shared Context: You make eye contact with someone across the table at MuleHacks. You both want to connect.
The Signal: Instead of asking for their phone, you both share a physical intent — like raising your coffee cups, or flashing a peace sign toward your webcams.
The Bridge: Glance's AI visually detects this synchronized physical gesture on both devices simultaneously.
The Reveal: The interface blurs out the live camera feed and executes a dramatic, physics-based UI transition. The air gap is bridged, and the other person's full digital identity — Name, Bio, GitHub, LinkedIn — springs onto your screen.
The Conversation: A private ephemeral chat room opens between the two of you instantly — no account, no room code, no cold message request.

No room codes. No typing. Zero clicks. Just a physical gesture instantly converted into a secure, bilateral digital handshake.

How we built it ⚙️

To achieve world-class polish in a single hackathon session, we froze an API JSON contract in the first hours and split our architecture into two strictly decoupled systems — frontend and backend developed fully in parallel.

1. The Retina (AI & Backend Engine)

Framework: A single-worker Python FastAPI server. To eliminate database latency and keep matching times under 3 seconds end-to-end, we used an in-memory dictionary store — deliberately choosing speed over persistence for the hackathon context.
Vision Loop: Every 3 seconds, the frontend captures a webcam frame, draws it to an off-screen canvas, downscales it to 480p, and compresses it into a low-quality JPEG — keeping payloads under 80KB before hitting the AI.
Multimodal Core: We integrated Google Gemini via the google-genai SDK. Instead of using it as a chatbot, we engineered a strict structured-output prompt with a JSON schema enforcing a fixed enum (coffee_cup, peace_sign, or none). Gemini becomes a high-speed binary spatial classifier, not a conversational model.
Atomic Temporal Matcher: If an intent is detected, the server runs a sliding 5-second time-window algorithm. It searches recent_pulses for another user in the same physical zone who triggered the exact same intent within that window. Critically, the match write is atomic — no await between the lookup and the store write — eliminating race conditions entirely.

$$\text{match}(a, b) \iff g_a = g_b \;\wedge\; z_a = z_b \;\wedge\; |t_a - t_b| \le 5\ \text{s}$$

Zone System: Users self-declare their physical location (Hacker Area, Hardware Lab, Main Stage, Lounge, Mentor's Corner) on entry. The matcher enforces zone-locality — you can only match someone physically near you, not someone across the building. Zones update live with user counts, refreshing every second.
Ephemeral Chat: On match, both users share a deterministic chat_id = sorted([user_a, user_b]).join("_"). A private polling-based chat room opens between them — no WebSocket infrastructure needed.
Connection History: Every match is persisted to a connections log, letting users review everyone they've Glanced with across the full event.

2. The Interface (Frontend & Spatial UX)

Stack: Next.js 16, Tailwind CSS, and Framer Motion, deployed on Vercel.
Cinematic Design: We deliberately avoided the "hackathon dashboard" cliché. We designed a spatial UI inspired by Apple VisionOS and Linear — deep dark modes, custom CSS grayscale filters on the live webcam feed, frosted glassmorphism via backdrop-blur, and a persistent animated radar overlay that pulses with detected signal strength.
State Machine UI: The interface transitions fluidly across five explicit states: IDLE → DETECTED → INTENT → VERIFYING → MATCH. Each state has distinct visual language — from muted grayscale scanning to full-color identity reveal.
Physics Animations: Framer Motion spring physics power the "Identity Reveal" — the card doesn't just appear, it feels like it has mass. A custom chime fires via the WebAudio API, unlocked on first interaction to respect browser autoplay policies.
Dual Poll Architecture: A 3-second pulse loop sends camera frames to Gemini. A parallel 400ms match-poll loop checks for a partner — giving sub-half-second response time after a match lands, without overloading the AI.

Challenges we ran into 🚧

The Latency Trap: Streaming live video to an LLM usually results in 5+ seconds of lag. We solved this by aggressively optimizing the capture pipeline: off-screen canvas rendering, 480p downscaling, and aggressive JPEG compression to keep payloads under 80KB per frame. End-to-end match latency: under 3 seconds.
Gemini API Version Labyrinth: The google-genai Python SDK underwent a major breaking API change. Reference implementations used client.interactions.create() — an agent system endpoint — not the image classification endpoint. After diagnosing consistent 400 errors in our server logs, we identified that client.models.generate_content with types.Part / types.Blob was the correct path for multimodal vision calls.
The Thinking Budget Bug: We initially included thinking_config=ThinkingConfig(thinking_budget=0) in our Gemini config — a parameter that gemini-3.5-flash-lite doesn't support. Every single pulse was returning 400. We diagnosed it via timing: the errors were arriving in ~200ms — far too fast for a real Gemini call — confirming the request was being rejected before inference. Removing thinking_config entirely fixed detection immediately.
Temporal Desynchronization: Humans don't move with robotic precision. One person might raise their cup 2 seconds before the other. Our 5-second sliding window caches intents in recent_pulses, checking for overlaps rather than requiring millisecond-perfect synchronization — while still feeling "simultaneous" from the user's perspective.
Three-Way Gesture Collision: What happens if three people all raise their cups at the same moment? Our atomic matcher ensures the first two are paired deterministically and removed from the pending pool. The third keeps scanning, waiting for a fourth. No double-matching, no phantom connections — purely deterministic first-come-first-served.
Hallucination Control: LLMs want to be conversational. We constrained Gemini with a strict response_schema JSON schema and response_mime_type: "application/json" — forcing it to act like a hardware sensor returning only a fixed enum value, never prose.
Zone Key Normalization: The identity page stored zones as display names ("Hacker Area") while the zone switcher used underscore keys (hacker_area). The backend normalizes to lowercase but not underscores — causing live zones to appear as duplicates. We added a toKey() normalization layer at every boundary: on registration, on API response, and on zone comparison.

Accomplishments that we're proud of 🏆

Engineering an Invisible UI: The primary interaction happens outside the screen. The app's job is to get out of the way and let a physical human moment happen.
Turning an LLM into a Real-Time Sensor: We successfully repurposed a generative multimodal model into a high-speed, spatial classification trigger with deterministic JSON output — not a single line of conversational AI.
Bilateral Consent by Architecture: The system is physically incapable of connecting you to someone who hasn't signaled. The gesture IS the opt-in. Privacy isn't a policy — it's enforced by the matching algorithm itself.
Production-Grade Polish in One Session: Custom font stack (font-telemetry, font-code-micro), physics-based reveal animations, WebAudio chime, radar overlay, animated aperture viewfinder, live zone density — all shipped in a single hackathon.
Flawless Parallel Execution: By freezing the API contract early, frontend and backend were built completely independently and integrated with zero major refactoring.

What we learned 🧠

Context is King: The best technology disappears. Users don't want to use an app to connect — they want the app to facilitate a natural human interaction and then vanish.
Multimodal is the Next Primitive: Text prompts are just the beginning. Giving an LLM "eyes" and using its output to trigger physical-world actions — not generate text — opens an entirely new paradigm of software development.
Atomicity Matters More Than Speed: In a concurrent matching system, correctness beats throughput. One misplaced await could create a ghost match between three people. The critical section must be synchronous.
Diagnose Before You Fix: Both of our major backend bugs (wrong SDK method, unsupported thinking_config) were solved by reading logs, not guessing. The 200ms failure timing told us the request never reached inference.

What's next for Glance 🚀

Constellation View: A data-visualization node graph mapping how and where you've connected with different people across physical zones — your social topology at a glance.
Expanded Gesture Vocabulary: Train a fine-tuned vision model on custom gestures — a specific wave, a finger-gun, a book held up — letting communities define their own connection signals.
Local WebRTC Mesh: Once Gemini verifies physical intent, spin up a local WebRTC P2P tunnel to swap contact data entirely offline — no cloud, no server, no latency.
Wearable Integration: Move Glance off the laptop and onto smart glasses (Ray-Ban Meta, future Apple Vision). The ambient connection protocol should follow you everywhere — connect with a nod, a handshake, or a shared glance across a crowded room.
Event Organizer Dashboard: Real-time zone density heatmaps, connection velocity metrics, and gesture signal analytics — letting organizers see the social pulse of their event as it happens.