MentraOS: An Open Source Runtime for Building Once and Running on Multiple Smart Glasses

The Problem: Fragmented Smart Glasses Development

Smart glasses development is fragmented. Each hardware vendor has its own SDK, pairing protocol, and data streaming format. A developer who wants to reach users on Even Realities and Vuzix devices must write and maintain separate codebases. MentraOS aims to remove that duplication. The README describes a runtime that handles pairing, connection, data streaming, and hardware access, so an app can run on any supported pair of glasses. The target audience is clear: developers and businesses that want one codebase for multiple glasses, and companies deploying glasses for field work, remote support, or accessibility. The promise is that development goes from months to days. That claim is not backed by any benchmark in the material, but the architectural approach makes the time saving plausible, at least for the supported devices.

The Architecture: A Phone Runtime, Not an On-Glasses OS

The name 'OS' is slightly misleading. MentraOS does not run on the glasses themselves. According to the README, the runtime runs on the phone inside the Mentra Runtime, and glasses apps run within that runtime. Multiple apps can run simultaneously, controlling the glasses through one shared connection. This design keeps the glasses lightweight, since all app logic lives on the phone. It also means one app works with any supported pair of glasses, because the runtime translates a common API to each device's protocol. The trade-off is obvious: if the phone is not present, or the app requires low-latency on-device processing, this model is a poor fit. The README also mentions that manufacturers can integrate the Mentra Runtime into their own iOS and Android apps, which would let them keep their brand while accessing the Mentra ecosystem. That is a reasonable path for hardware vendors who want app support without building their own app store.

Supported Hardware and the Reality of the List

The README lists five devices: Mentra Live, Even Realities G2, Vuzix Z100, Even Realities G1, and NIMO, with NIMO marked as coming soon. That is a short list. The table in the README highlights Even Realities G2 with a green border, which might indicate a flagship or best-supported device, but the material does not explain the color coding. Vuzix Z100 is a well-known enterprise-oriented device, so its inclusion makes sense for business deployment. Mentra Live appears to be the project's own glasses, though the README does not describe it. The absence of major brands like Ray-Ban Meta or Amazon Echo Frames is notable. The 'growing ecosystem' phrase suggests more devices are planned, but the current list is the only one you can rely on. If your target device is not on this list, MentraOS is not usable for you today.

Getting Started: What the README Actually Provides

The README is light on setup instructions. It links to a documentation site at docs.mentra.glass and a developer console at console.mentra.glass, but it does not include a single command to install or build the project. There are no code snippets, no API examples, and no configuration keys in the README. The repository is TypeScript, and the default branch is 'dev', which suggests active development. The release tags are all 'dev' builds, with the most recent being mentra-v3.1.0-dev.28 from 2026-08-26. The nightly builds section links to APK files from a different GitHub repository (TeamOpenSmartGlasses/DiscussPlusPlus), which is confusing. The README says to join the Discord for community support and to check the contributor guide for how to contribute. For an engineer evaluating this project, the first step would be to clone the repository and read the source code, because the README alone is not enough to understand how to build an app. The documentation site is the missing piece, and it is not included in the provided material.

Distribution and Business Deployment: The MiniApp Store

MentraOS includes an app distribution channel: the Mentra MiniApp Store. The README says apps can be published there and reach users across the MentraOS ecosystem. This is a significant feature, because it gives developers a route to users without building their own installer. The store is browsable from a phone, and the README lists example apps: captions, AI notes, proactive AI, translation, and streaming. For business deployment, the README claims MentraOS is already being deployed by Fortune 500 companies. That claim is not verifiable from the material, but the existence of a MiniApp Store suggests a managed distribution model. The MIT license applies to the OS code, but the store itself is a service, and the terms for publishing are not described. If you are building a proprietary app, you need to check the store's terms separately. The README also emphasizes privacy and freedom from hardware or cloud lock-in, which is consistent with the MIT license and the open source approach.

Licensing and Maintenance Costs

The project is MIT-licensed, which is permissive and allows commercial use, modification, and redistribution. That is a strong point for businesses that want to avoid open source license obligations. The copyright is held by Mentra Labs, Inc., and the license text is standard. The maintenance cost is harder to assess. The default branch is 'dev', and all recent releases are 'dev' builds, which indicates that the project has not yet reached a stable 3.1.0 release. The release cadence is high: three releases on the same day (2026-08-26) suggests rapid iteration, but also potential instability. The README points to a community Discord and help-wanted issues, which suggests the project relies on external contributors. For an engineer, adopting a project with only dev releases means you should expect API changes and potential breakage. The documentation site is the place to check for upgrade guides, but it is not included in the material. The MIT license reduces legal risk, but the operational risk of a moving target remains.

Alternatives and the Real Difference in Approach

The primary alternative to MentraOS is using vendor-specific SDKs directly. For example, Vuzix offers its own SDK for the Z100, and Even Realities provides its own development tools. The difference is fundamental: with vendor SDKs, you write an app that runs on the glasses themselves or communicates directly with that vendor's protocol. You get deep integration and access to device-specific features, but you must repeat that work for each vendor. MentraOS abstracts that layer, so you write once and run on multiple devices. The trade-off is that you lose access to vendor-specific features that are not exposed through the common API. Another alternative is to use a different cross-platform framework, but the README does not mention any. The choice comes down to whether your priority is breadth of device support or depth of integration with a specific device. If you only target one device, the vendor SDK is likely simpler and more reliable. If you need to reach multiple devices, MentraOS is the only option in the material that offers that abstraction.

What to Verify Before Adopting MentraOS

The README is a marketing document, not a technical manual. Before adopting MentraOS, you need to verify several things that the README does not cover. First, check the documentation at docs.mentra.glass for the actual API surface. The README mentions displays, microphones, cameras, and speakers, but it does not show how to access them. Second, examine the repository's source code to understand the runtime's architecture and whether it is mature enough for production. Third, test the nightly builds, since the release tags are all dev versions. Fourth, confirm that the Mentra MiniApp Store is open to third-party developers and what the review process is. Fifth, evaluate the device support: the README lists five devices, but you need to know how well each is supported and whether the 'coming soon' NIMO is a risk. Finally, consider the community: the README invites contributions and points to Discord, but the project's governance and roadmap are not described. These are the gaps you must fill before committing.

Editorial conclusion

Adopt MentraOS if you are a developer or business wanting to build smart glasses apps without writing device-specific pairing and data streaming code, and if you accept the current hardware list (Even Realities G1/G2, Vuzix Z100, Mentra Live) and the phone-centric runtime model. Do not adopt it if your target device is not on the supported list, if you need on-glasses processing, or if you require a stable production release, since the default branch is 'dev' and recent releases are all 'dev' builds. Before committing, verify the actual state of the runtime by cloning the repository and checking the documentation at docs.mentra.glass, because the README alone does not provide enough detail on the API surface or device-specific behavior.

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes