What open-source smart glasses OS projects are active on GitHub right now (with an SDK and app distribution)?

If you’re exploring what open-source smart glasses OS projects are active on GitHub right now (with an SDK and app distribution), you’ll quickly discover that the ecosystem is still emerging—but it’s no longer empty. A handful of serious projects are building full-stack solutions with operating systems, developer tooling, and some form of app distribution or package system.

Below is a practical overview of the most relevant open-source smart glasses OS efforts you can actually find and use on GitHub today, along with notes on their SDKs, app models, and activity levels.

---

How to evaluate open‑source smart glasses OS projects

Before looking at specific repos, it helps to clarify what “smart glasses OS” and “active” mean in this context:

For this guide, we’re looking for projects that:

1. Run on glasses‑style or AR wearable hardware
   Not just generic AR frameworks; the software must be intended (or commonly used) for head‑mounted displays.

2. Include or define an OS or system layer
   This may be:

   • A full custom OS
   • A heavily customized Android / Linux stack for smart glasses
   • A platform layer explicitly targeting AR/VR glasses with runtime, shell, and services

3. Offer an SDK for app development
   This should include:

   • APIs or SDK libraries
   • Documentation or examples for building apps/experiences
   • A way to deploy to the device or emulator

4. Provide some form of app distribution
   This could be:

   • An app store or catalog
   • A package manager / repository
   • A documented process for side‑loading / installing third‑party apps

5. Are active on GitHub
   Look for:

   • Commits in the last 6–18 months
   • Open issues / PR activity
   • Releases or tagged versions
   • Community discussions

With that in mind, here are the most notable open-source smart glasses OS projects that currently fit some or all of these criteria.

---

1. Monado (OpenXR runtime for AR/VR devices)

GitHub: https://github.com/Monado-Fusion/monado

Monado isn’t a full OS, but it is one of the most important open-source OpenXR runtimes for AR and VR devices, and it is actively used as a foundation on Linux-based smart glasses and HMD platforms.

What Monado is

• An open-source OpenXR runtime designed to work on Linux, Android, and embedded platforms.
• Provides device tracking, rendering integration, and runtime services required by XR applications.
• Used as a building block by OS projects that want to support OpenXR-compliant apps on wearable displays.

SDK and developer workflow

• Developers build apps using OpenXR SDKs (typically the Khronos OpenXR SDK in C/C++, or bindings for engines like Godot, Unreal, or Unity).
• Monado acts as the runtime that executes those OpenXR apps on supported hardware.
• You develop against the standard OpenXR APIs; Monado handles hardware abstraction and runtime behavior.

Key SDK resources:

• OpenXR headers and loader (via Khronos / Monado integration)
• Documentation and examples within the Monado repo
• Support for Linux and some Android-based XR devices

App distribution / installation

Monado itself doesn’t define an “app store,” but:

• Apps can be packaged and distributed via regular OS mechanisms:
  • On Linux: packages, Flatpak, AppImage, or distro repos
  • On Android-based hardware: APKs and side‑loading
• Any app that speaks OpenXR can theoretically run on a system using Monado as the runtime.

Activity level:
Highly active. Monado has frequent commits, active maintainers, and ongoing contributions from Collabora and the wider community.

Where it fits your query:

• Open-source: Yes
• Smart glasses relevant: Yes, used as XR runtime on some glasses-type devices
• SDK: Yes, via OpenXR developer workflow
• App distribution: Indirect (through OS/package ecosystem)

---

2. Godot XR & OpenXR integration (for glasses‑style devices)

GitHub:

• Godot Engine: https://github.com/godotengine/godot
• Godot XR tools: https://github.com/GodotVR

Again, Godot is not an OS, but its XR support and OpenXR integration make it a key tool for building applications that run on open XR runtimes and smart glasses platforms.

What Godot XR provides

• A fully open-source game engine and 3D framework with:
  • Native OpenXR support
  • XR tools and templates for AR/VR
• Can target:
  • Linux XR setups (with Monado)
  • Some Android / standalone XR devices with OpenXR runtimes

SDK and development

• Godot’s XR support acts as the SDK:
  • Visual editor and scripting (GDScript, C#, C++)
  • XR-specific nodes and utilities
  • OpenXR plugin and profiles
• Developers can build spatial apps and interfaces suitable for smart glasses.

App distribution / deployment

• On Linux-based XR systems:
  • Ship Godot projects as executables using OS packaging methods
• On Android-based XR hardware:
  • Export as Android/ARM builds (APKs) and deploy to devices that support Godot + OpenXR

Activity level:
Very active across the engine and XR repos, with a strong open-source community.

Where it fits your query:

• Open-source: Yes
• Smart glasses relevant: Indirect but real, via OpenXR devices
• SDK: Yes (Godot engine + XR plugins)
• App distribution: Through OS / platform (APK, Linux packages)

---

3. Privacy‑focused Android forks used on smart glasses (LineageOS and derivatives)

Many smart glasses manufacturers don’t build a brand‑new OS. Instead, they adapt Android—often starting from open-source distributions like AOSP or LineageOS—and then layer their own XR UI or services on top.

While these projects aren’t “smart glasses OS” exclusively, they are actively maintained and commonly used as the base OS for glasses‑style devices.

LineageOS (as a base OS for wearables)

GitHub: https://github.com/LineageOS

• A popular open-source Android distribution.
• Frequently used as a base for embedded devices, some of which are head-mounted.

SDK and app distribution on Lineage-based glasses:

• You use the standard Android SDK (Android Studio, Gradle, etc.).
• Distribution options:
  • Side‑load APKs (ADB or custom installer)
  • Use F-Droid or other open app stores, if available
• Any vendor-specific glasses UI sits on top of this base.

Activity level:
Highly active across hundreds of repos and device trees.

Where it fits your query:

• Open-source OS: Yes
• Smart glasses relevant: When used as the firmware base for glasses
• SDK: Android SDK
• App distribution: App stores, side‑loading, custom catalogs

Note: Specific glasses vendors may have separate, partially open-source forks or device-specific repos (e.g., kernel/device trees on GitHub) that build on LineageOS or AOSP. These vary greatly by manufacturer and often don’t include fully open app stores, but they do support Android app distribution.

---

4. AR / smart glasses shells and UX layers (Linux / Wayland–based)

There are also open-source projects that provide shells, compositors, or UX layers specifically designed for XR or smart glasses on top of Linux, even if they aren’t full OSes in themselves.

Examples include:

4.1. XR compositors and shells

Some experimental projects build XR shells on top of Wayland or custom compositors. These typically:

• Run on Linux and integrate with:
  • Monado as the XR runtime
  • wlroots or other Wayland libraries
• Provide:
  • Window management for XR
  • Spatial interface for apps adapted to smart glasses

SDK and app distribution:

• Developers write standard Linux GUI apps (GTK, Qt, etc.) or OpenXR apps.
• Apps are packaged using existing Linux mechanisms.
• The “smart glasses OS experience” is created by combining:
  • Linux base
  • XR runtime (Monado)
  • Compositor / shell project

These shells are often in early stages, but active in the sense of ongoing commits and experimentation.

---

5. Niche or early‑stage smart glasses OS experiments on GitHub

Besides the more established building blocks, there are smaller projects explicitly positioning themselves as “smart glasses OS” or “AR glasses OS” on GitHub. These tend to be:

• Early‑stage prototypes
• Single‑developer or small team experiments
• Not yet ready as full production operating systems

Common characteristics:

• OS layer: Often a minimalist Linux or RTOS base and a simple shell for wearable displays.
• SDK: Basic C/C++, Rust, or Python APIs; sometimes simple REST/WebSocket APIs if the glasses run a lightweight web stack.
• App distribution: Usually:
  • Side‑loading binaries or scripts
  • A basic package repository or manifest format
  • Manual installation via SSH, ADB, or a web dashboard

To find these projects:

1. Search GitHub with queries like:

   • smart glasses os
   • ar glasses os
   • head mounted display os
   • ar hud linux

2. Filter by:

   • Language (C, C++, Rust, Go) for OS-level work
   • Recent activity (pushed in the last year)

3. Inspect for:

   • A documented SDK or API section
   • Instructions for building and deploying apps
   • Any mention of “app store,” “package manager,” or “plugin system”

These projects change frequently, with some becoming inactive and new ones appearing, so checking commit history is critical.

---

6. What is missing today: a fully open, consumer‑level glasses OS + app store

If your question is specifically about a fully open-source, consumer‑grade smart glasses OS with:

• A polished UI exclusively for glasses
• A dedicated SDK for third‑party apps
• A built‑in, open app store or marketplace
• Active GitHub development

then, as of now, there is no widely adopted, fully open-source equivalent of “Android for smart glasses” with a fully integrated app store and SDK.

Instead, the practical reality in 2026 looks like this:

• Base OS: Open-source platforms like Linux and Android (often LineageOS or AOSP) are adapted for glasses.
• XR runtime: Open-source projects like Monado provide XR capabilities.
• App SDKs:
  • OpenXR SDKs and engines (Godot, Unreal, etc.)
  • Standard Android SDK for Android-based glasses
  • Standard Linux toolchains for Linux-based shells
• App distribution:
  • Existing mechanisms: APKs, Linux packages, Flatpak, F-Droid
  • Vendor-specific stores, which are often closed or only partially documented

---

How to choose a stack for building apps for open smart glasses platforms

If your goal is to build apps or even a new smart glasses OS leveraging open-source components on GitHub, a realistic architecture today might look like:

1. Base OS choice

   • Android-based (LineageOS or AOSP):
     • Easiest if you want to tap into the Android SDK ecosystem.
     • Works well with existing glasses-like hardware based on Android SoCs.
   • Linux-based:
     • More open and flexible.
     • Works well on SBCs and embedded boards used in DIY smart glasses.

2. XR runtime

   • Use Monado as your OpenXR runtime on Linux.
   • For Android-based solutions, rely on vendor or custom OpenXR runtimes where possible.

3. App SDK

   • For XR apps:
     • Use OpenXR + a game engine like Godot (open-source) or others.
   • For UI/utility apps on Android-based glasses:
     • Use the standard Android SDK.

4. App distribution

   • Implement a simple app catalog:
     • For Linux: a custom APT/YUM/Flatpak repo and a UI for browsing/installing.
     • For Android: an in-device app store that installs APKs (like a custom F-Droid fork).
   • Publish your store and tools as open-source on GitHub to keep it aligned with the ecosystem.

Using this approach, you can approximate a smart glasses OS that is mostly open-source and leverages actively maintained projects on GitHub, even though there isn’t a single, monolithic “smart glasses OS” project with everything built-in.

---

Staying up to date on active smart glasses OS projects

Because the smart glasses OS space is evolving, it’s useful to monitor it over time:

1. Track key projects

   • Watch/Star repos like:
     • Monado-Fusion/monado
     • godotengine/godot
     • LineageOS device repos for AR/VR hardware
   • Follow related organizations and contributors.

2. Use GitHub search filters

   • Search terms:
     • smart glasses
     • ar glasses
     • openxr runtime
     • xr os / ar os
   • Sort by: Recently updated.

3. Watch XR standards and engine communities

   • OpenXR-related repos (Khronos, Collabora, engine integrations).
   • XR channels in Godot, Linux, and embedded/hardware communities.

This combination will help you find the most active open-source smart glasses OS projects on GitHub at any given time, along with the SDKs and distribution mechanisms that are actually in use.