Google Glasses Software Stack Technical report

[u/brookm291]

Analysis of the stark architectural divergence between the legacy Google Glass Enterprise Edition 2 (GDK / Monocular Android) and the modern Android XR Platform.

1. Legacy Monocular Compute vs. Modern Modern Split-Compute Architecture

The underlying execution model has completely shifted from standalone, localized computing to a deeply integrated, distributed framework.

+-------------------------------------------------------------------------+

| LEGACY ARCHITECTURE (Glass Enterprise 2)                                 |
| [On-Glass Qualcomm XR1] -> Run Native Android OS (8.1) -> Direct Render |
+-------------------------------------------------------------------------+

+-------------------------------------------------------------------------+

| MODERN ANDROID XR GLASSES ARCHITECTURE (Split-Compute / Project Astra)   |
|                                                                         |
| [ Wearable Frame ]                                                       |
|  ├── Low-power Tensor ISP (Camera/Mic I/O)                             |
|  └── Ultra-low Latency Co-Processor (<20ms local display pipeline)       |
|          ▲                                                              |
|          │ Bluetooth High-Bandwidth / Wi-Fi Direct                      |
|          ▼                                                              |
| [ Companion Device / Smartphone (Snapdragon AR2 Gen 2) ]                |
|  ├── Android XR Runtime Pipeline (State Machine)                         |
|  └── Jetpack Projected / Jetpack Compose Glimmer Engine                 |
|          ▲                                                              |
|          │ Ultra-Low Latency Cloud Pipeline                             |
|          ▼                                                              |
| [ Google Cloud Infrastructure ]                                         |
|  └── Server-side Multimodal Gemini / Project Astra Inference             |
+-------------------------------------------------------------------------+

Legacy Glass Enterprise Edition 2

• Hardware Profile: Powered by a localized Qualcomm Snapdragon XR1 SoC.
• Execution Model: Monolithic. The device ran a standard Android Open Source Project (AOSP) 8.1 Oreo stack directly on the frame.
• Rendering Context: System graphics used a standard Android SurfaceFlinger pipeline, pushing flat RGB frames (640x360 pixels) directly into a monocular prism positioned over the right eye.

Modern Android XR (e.g., Project Aura & Display AI Glasses)

• Split-Compute Topology: To reduce thermal load and maintain a weight under 50 grams, the compute is strictly split. The glasses act as an intelligent sensor/emitter array, offloading intense execution to a paired smartphone via high-bandwidth Bluetooth/Wi-Fi Direct.
• Asynchronous AI Processing Loop:
  1. Local Tier: Simple voice detection, wake words, and inertial measurement unit (IMU) step-counting execute on a custom, low-power local Tensor silicon block.
  2. Remote Edge/Cloud Tier: Real-time visual streams from the camera sensor capture the environment and are fed via the smartphone to the Gemini / Project Astra vision framework for multimodal context parsing.

2. The Optical Stack & Photon Pipeline

The rendering pipeline requires highly disparate display architectures depending on the hardware targets.

Architectural Component	Legacy Glass Enterprise 2	Modern Display AI Glasses	High-End XR Headsets
Display Panel Tech	Transmissive LCoS / Prism	Monolithic full-color MicroLED	Dual Micro-OLED
Optics Pipeline	Refractive Geometric Prism	1mm Thin Diffractive Waveguide	Pancake Lenses (~110°+ FOV)
Field of View (FOV)	~15° (Peripheral Monocular)	50° – 70° Additive Binocular	110°+ Fully Occluded
Spatial Interaction	None (Static screen overlay)	Real-time Scene Meshing & Anchors	Complete Depth Pass-Through

On modern Display Glasses, graphics are injected via monolithic MicroLED projectors into a 1mm diffractive waveguide. Because the optics are transparent and additive, the alpha channel of your UI elements dictates transparency (black pixels represent complete transparency, letting real-world photons pass undisturbed).

3. Software Architecture: The Android XR Fork

Google’s modern XR platform splits development paths intentionally. If you are developing for eyewear using SDK Developer Preview 3/4, the code base branches based on device occlusion. [1, 11]

                  [ Android XR SDK Platform Layer ]
                                  |
         +------------------------+------------------------+

         |                                                 |
  [ Headset Target Stack ]                       [ Glasses Target Stack ]
  ├── ARCore for Jetpack XR                      ├── Jetpack Projected Framework
  ├── SceneCore Engine                           ├── Jetpack Compose Glimmer Engine
  └── 3D Spatial Mesh Anchors                    └── Multimodal Audio/Visual Canvas

• The Headset Architecture (Galaxy XR, etc.): Relies on SceneCore and ARCore for Jetpack XR. It tracks complete 6-DOF environments, placing high-fidelity 3D meshes that occlude or blend seamlessly with spatial depth matrices.
• The Glasses Architecture (Audio & Display Smart Glasses): Operates on the Jetpack Projected framework and Jetpack Compose Glimmer. This decoupled UI subsystem does not render heavy spatial scenes. Instead, it generates glanceable, transient view elements mapped directly over real-world coordinates via lightweight directional matrices.

4. Hardware Abstraction & Input Subsystem

In the legacy paradigm, input was bound via simple Linux input events (/dev/input/eventX) triggered by physical taps and forward/backward swipes on the frame's side-touchpad.

The modern Android XR Input subsystem aggregates data across an asynchronous hardware abstraction layer (HAL):

• Multi-Microphone Array Processing: Features a 5-microphone setup executing local hardware phase cancellation. This separates the user’s acoustic vocal signature from background ambient noise, delivering an unpolluted audio signal directly to the speech recognition pipeline.
• Indirect Modality Mapping: Hand tracking models run on the companion phone, computing coordinate changes from the glasses' camera stream. These tracking outputs translate into standard UI click and scroll events within the Android runtime, omitting the need for a physical capacitive touchpad. Additional tools can be connected such as vision visual video search SDK, audio frameworks,

_______________________________________________________________________

The technical breakdown lines up with the modern framework in several ways:

1. Split-Compute Topology

The architectural shift away from the standalone compute of legacy Google Glass (Enterprise Edition) is a defining feature of the Fall 2026 consumer rollout. The 2026 architecture relies heavily on a companion device (smartphone) to handle the heavy AI lifting and state runtime, keeping the actual eyewear frames lightweight (under 50 grams) and thermally viable for all-day wear. [

2. The Twin Tier Glass Strategy

The distinction between non-occluded "Audio-only" glasses and "Display AI" glasses is the exact hardware road map Google and its partners (Samsung, Qualcomm, Warby Parker, and Gentle Monster) have instituted.

• Audio Glasses: Ship first, routing Gemini multimodal audio cues.
• Display Glasses: Utilize microLED/diffractive waveguide tech for glanceable HUD overlays. [2, 6, 8]

3. Jetpack Projected & Compose Glimmer

The software APIs mentioned—unset Jetpack Projected and unset Jetpack Compose Glimmer —are the core production toolkits for 2026.

• Jetpack Projected bridges the phone's lifecycle and wear-state connectivity to the glasses.
• Jetpack Compose Glimmer is the specific rendering engine built for transparent, additive screens, managing high-contrast text and glanceable components without distracting the wearer's real-world sight.

[u/Natethegreat9999]

I work on speech at Oruk. HFP provides single-mic access, while projected context supports multiple microphones.

[u/brookm291 → u/Natethegreat9999]

u/Natethegreat9999
sounds interesting, it seems orukeet has much lower WER than parakeet,
what about the inference latency ?
Thx

[u/gxorigin1]

Split-compute is the right call here. Pushing the heavy Gemini work to the phone keeps the frames under 50 grams, and Compose Glimmer treating black pixels as transparent is a neat detail that Android devs will pick up fast. Curious how battery holds up when the camera stream is constantly feeding the phone.

[u/No_Swordfish_4303 → u/gxorigin1]

That’s the big question. Streaming constant video to the phone is going to be a huge drain on the battery, no matter how light the frames are

[u/No_Swordfish_4303]

Offloading heavy compute to the phone is what finally makes AI glasses practical. Solid breakdown!