Living With (and Building For) the Even Realities G2 Smart Glasses: A Review and Developer Tutorial

I’d recommend these glasses to almost nobody. I also can’t stop wearing them.

I was halfway through a conversation with a prospective client when they mentioned that their company had recently expanded into three new European markets.

A few seconds later, a small line appeared at the edge of my vision.

CONTEXT: Expansion announced last quarter. Germany and France are performing above expectations. Spain is still in pilot.

I hadn’t asked anything. I hadn’t looked at my phone. I hadn’t broken eye contact.

I just kept talking.

A few minutes later, the conversation moved to customer acquisition. The client mentioned a number that didn’t quite match what had been reported publicly.

CHECK: That figure appears to include existing customers. Reported net-new acquisition is lower.

Again, I did nothing.

This is the experiment I’ve been building: an insight agent that listens alongside me, connects what it hears with public information and my own second brain, and decides when something is useful enough to surface in my field of view.

It can fact-check a claim. Remind me that we discussed the same problem six months ago. Surface a relevant note I’d forgotten. Connect what someone is saying now with something I read last week.

But the most important thing it does is nothing.

Most of the conversation passes without a single notification. There’s no chatbot waiting for prompts, no screen competing for my attention, no stream of AI commentary.

Then, occasionally, one useful thought appears.

And for a moment, it doesn’t feel like using a computer.

It feels like remembering something at exactly the right time.

So this piece does three jobs. It’s a review of a pair of glasses that most people shouldn’t buy. It’s a tutorial for the few who should. And it’s an honest account of what a week of designing for 576 by 288 pixels of monochrome green did to my habits as a designer.

What you’re actually buying

The G2 is a pair of glasses that can show you text. That’s the most useful way to think about it, and the least flattering. It is not a computer on your face, and it’s not trying to be.

They cost €699 in Italy ($599 in the US). Prescription lenses are extra, from €169 in Germany, and the optional R1 ring, a ceramic controller that also tracks sleep and heart rate, is another €269. Reviewers are split on the ring. Some call it close to essential, others call it redundant. The temple touchpads do everything it does, just less discreetly.

The spec sheet, translated into what it means on your face:

• 36 grams. A magnesium front and titanium temples. They look and weigh like normal glasses, which is the point of the whole product.
• A green micro-LED display in both lenses. The panel is 640×350, but apps get a 576×288 canvas. It has 16 shades of green, a 27.5° field of view, and up to 1,200 nits. In practice that’s a floating strip of text in the upper part of your vision.
• No camera. No speakers. Nobody near you is being filmed, and nothing talks back. Everything comes to you as text.
• Four microphones, touchpads on both temples, a compass and motion sensor, and an ambient light sensor for auto brightness.
• Two days of typical use, with a charging case that holds about seven full charges.
• IP65, and prescriptions from -12 to +12.

That list is short on purpose. Even Realities decided what to leave out before deciding what to put in, and the omissions are the product. A camera would make it a surveillance device. Speakers would make it an earbud. Colour would make it heavier and hungrier. What’s left is a quiet, legible, slightly austere HUD that you can wear to a client meeting without anyone asking about it.

Sorted Pixels is a reader-supported publication. To receive new posts and support my work, consider becoming a free or paid subscriber.

You forget the frame, not the display

The frames disappear. The display never quite does, and I think that’s the most honest sentence I can write about this device.

Physically, you stop noticing them within an hour. There’s no heat, no hum, no weight on your nose. When the display is off, they’re just glasses. That’s a real achievement, and it’s the thing every other smart glasses maker is still chasing.

The display is a different story, because it’s designed to pull your eyes. Text in your upper field of view is a small magnet. Android Police’s reviewer admitted it was far too tempting to read while driving, and 9to5Mac raised the same worry about cycling. I felt it too. A notification you’d ignore on your wrist is much harder to ignore when it’s floating over the person you’re talking to. The same reviewer found that live conversation cues pulled him out of real conversations, which is the opposite of what they’re for.

A few other things you only learn by wearing them:

• Outdoors is fine, mostly. Legible in daylight, a bit weaker in harsh sun or against busy backgrounds. Even sells a clip-on shade for exactly this.
• The tells are small but real. A slightly thicker temple, a faint glow if someone looks closely, and the habit of touching the side of your head. Yahoo’s reviewer said wearers look like they’re constantly adjusting their frames. That’s fair.
• No camera changes how people treat you. Nobody asks if you’re recording. After years of watching people flinch at camera-glasses, that alone feels like a design decision worth defending.

So when I say you forget you’re wearing it, I mean the object. The attention cost is still yours to manage, and as a designer, that turned out to be the whole job.

The stock software, honestly

If you’d bought the G2 at launch in November 2025, you’d have bought beautiful hardware running software that wasn’t finished. Engadget said so plainly: “the company’s software just isn’t ready yet.” Pairing was fiddly, the ring was imprecise, auto brightness misbehaved.

The built-in apps are sensible and a bit thin:

• Conversate listens and surfaces cues and summaries during a conversation. Since March 2026 you can upload documents beforehand and it will pull notes and fact-checks from them. It stumbles on product names and jargon, which will matter later.
• Translate shows live subtitles in around thirty languages. This is the one that makes people’s jaws drop.
• Teleprompt scrolls your notes as you speak. Genuinely useful if you present a lot.
• Navigate turns with your head thanks to the compass. Wareable called it closer to a proof of concept, and I agree.
• Even AI is a voice assistant that mixes Even’s own model with ChatGPT and Perplexity. No subscription.

What changed my verdict wasn’t any of these. It was April 2026, when Even opened Even Hub, a store and a public SDK. It launched with around fifty apps and more than two thousand developers already building. A few weeks later, firmware 2.2.0 added Terminal Mode, which shows you whether an AI coding agent is thinking, running or waiting for you, and lets you approve its next step with a tap.

Read that last sentence again if you work with agents. Your coding agent is in the other room, running a long task, and your glasses quietly tell you when it needs a yes. That’s not a demo feature. That’s the shape of how I think we’ll all supervise agents in a couple of years.

By August, Wareable was describing the glasses as fundamentally transformed by the updates. The hardware didn’t change. The platform arrived.

Your phone is the computer

The first thing that breaks your mental model is that the glasses don’t run your code. They’re a screen, a microphone array and a few touch sensors, connected to your phone over Bluetooth Low Energy. Nothing else.

An Even Hub app is a web app. HTML, CSS and TypeScript, running inside a WebView in the Even Realities phone app. Your code talks to a bridge. The bridge talks to the glasses. The glasses draw what you send and report what you touch.

That shape has consequences you’ll feel on day one:

• You don’t draw pixels, you declare containers. Text boxes, lists and greyscale image boxes, positioned on the 576×288 canvas. Up to twelve per page, and only one of them receives input.
• The firmware owns the rendering. One built-in font, a fixed 27 pixel line height, no colour. If a character isn’t in the firmware font, it simply doesn’t appear.
• The firmware owns scrolling, too. You can’t move a viewport. You get told when the user hits the top or bottom of a container, and that’s it.
• The phone does everything else. Network calls, speech-to-text, your model, your state. The glasses can stream audio to you (16 kHz, one stream), send motion data, and tell you which temple or the ring was touched.

I spent real effort trying to make my apps work without the phone. They can’t, and that’s by design. What you can do is install your app so it shows up in the glasses’ own menu and launches with a tap on the temple. The phone stays in your pocket, which is the honest version of “standalone”.

Tutorial: your first app on the lens

If you can run npm install, you can put text on your own glasses in about half an hour. Here’s the path I’d take now, knowing what I know. Versions are as of late September 2026 (SDK 0.0.16, CLI 0.1.14), and this platform moves weekly, so check the official quickstart if something doesn’t match.

1. Set up the phone side

Install the Even Realities app and create an account. Pair the glasses and take the firmware update before anything else. Even’s own docs trace most “it won’t connect” reports to old firmware.

Then sign in at hub.evenrealities.com with the same account. Force-quit and reopen the phone app, and a developer section appears in the Even Hub tab. That’s where your test apps will live.

2. Install the tools

You need Node 20, or 22 and later. Then:

npm install -g @evenrealities/evenhub-cli @evenrealities/evenhub-simulator

The CLI is called evenhub (or eh for short). The simulator gives you a green 576×288 canvas on your laptop, which is where you’ll spend most of your time.

3. Start from the official template

npx degit even-realities/evenhub-templates/minimal hello-g2
cd hello-g2
npm install

There are other templates in the same repo (text-heavy, speech recognition, images). Start with the minimal one. It’s small enough to read in two minutes, and it teaches you the one thing that tripped me up most.

4. Read the twenty lines that matter

Here’s the heart of it, trimmed down. One full-screen text container, a tap counter, and a double-tap to exit.

import {
  waitForEvenAppBridge,
  TextContainerProperty,
  CreateStartUpPageContainer,
  TextContainerUpgrade,
  OsEventTypeList,
} from '@evenrealities/even_hub_sdk'

const bridge = await waitForEvenAppBridge()

await bridge.createStartUpPageContainer(
  new CreateStartUpPageContainer({
    containerTotalNum: 1,
    textObject: [
      new TextContainerProperty({
        xPosition: 0, yPosition: 0, width: 576, height: 288,
        paddingLength: 4,
        containerID: 1, containerName: 'main',
        content: 'Hello from G2.\nTap to count, double-tap to exit.',
        isEventCapture: 1,
      }),
    ],
  }),
)

// A tap is CLICK_EVENT, whose value is 0. Zero values vanish on the
// wire, so a tap arrives with eventType undefined. Resolve it per envelope.
const typeOf = (e?: { eventType?: OsEventTypeList }) =>
  e ? (e.eventType ?? OsEventTypeList.CLICK_EVENT) : null

let taps = 0
bridge.onEvenHubEvent((event) => {
  const sys = typeOf(event.sysEvent)   // taps, double taps, lifecycle
  const text = typeOf(event.textEvent) // scroll gestures

  if (sys === OsEventTypeList.DOUBLE_CLICK_EVENT ||
      text === OsEventTypeList.DOUBLE_CLICK_EVENT) {
    bridge.shutDownPageContainer(1) // always let people leave
    return
  }

  if (sys === OsEventTypeList.CLICK_EVENT ||
      text === OsEventTypeList.CLICK_EVENT) {
    taps += 1
    bridge.textContainerUpgrade(new TextContainerUpgrade({
      containerID: 1, containerName: 'main',
      content: `Taps: ${taps}\nTap to count, double-tap to exit.`,
    }))
  }
})

Three things in there cost other people (and me) hours:

• Taps and scrolls arrive on different channels. Taps and double taps come in as sysEvent, scroll gestures as textEvent. Early code samples only listened to one, and on real hardware the taps simply never arrived.
• A tap looks like nothing. Because its value is zero, it shows up as undefined. If you check for CLICK_EVENT directly, your tap handler never fires. If you default carelessly, every scroll fires it instead.
• Double tap must always exit. It’s a store review rule, and it’s also just decent manners on a device people wear on their face.

Also worth knowing: use textContainerUpgrade for updates rather than rebuilding the page, or you’ll see flicker. And if you want the glasses microphone, create the page first, then call audioControl. The other way round quietly fails.

5. Run it in the simulator

npm run dev
evenhub-simulator http://localhost:5173

Tap with your mouse, watch the counter go up. This loop is fast, and it’s where you should iterate on layout.

6. Run it on your face

Find your laptop’s local IP address, then:

evenhub qr --url "http://192.168.1.20:5173"

Scan the QR code from the developer section of the phone app. Your app opens on the glasses, and hot reload works, which still feels a bit like magic.

If the QR scans and nothing loads, it’s almost always the network. Make sure Vite listens on your LAN (server: { host: true } in vite.config.ts), check your firewall, and watch out for office or guest Wi-Fi that isolates devices from each other.

7. Measure your text, don’t guess it

This is the step nobody tells you about, and the one I’d make mandatory. Install the measurement package:

npm install @evenrealities/pretext

It predicts exactly how the firmware will lay out your text, using the real font metrics:

import { getTextWidth, measureTextWrap } from '@evenrealities/pretext'

// 576 wide, minus 4px of padding on each side
const layout = measureTextWrap(myText, 568)
console.log(layout.lineCount) // more than 10? you have a paging problem

// A glyph the firmware doesn't have comes back suspiciously narrow
console.log(getTextWidth('█'), getTextWidth('░')) // 20 vs 4 on my tests

That last line is a trick I stumbled into, and I’ll come back to it.

8. Package and share

npm run build
evenhub pack app.json dist -o hello-g2.ehpk

Upload the .ehpk in the developer portal, push it to a beta group, and install it from the phone app. Once it’s installed this way, it appears in the glasses menu and launches from the temple, no QR code needed.

The app.json manifest is where you declare your app’s id, name and permissions. Network access needs a whitelist of domains, and the microphone needs its own permission. Check the manifest reference for the current names, because they’ve changed before.

If you want to go public, apps go through manual review. The rules are short and worth reading even if you never submit, because they’re really design guidance. Reviewers test with the phone locked and the app in the background. The core flow has to work with glasses and ring alone. Every gesture needs a visible response. And the app should never show a black screen on first launch.

One more shortcut: Even maintains an official Claude Code plugin, everything-evenhub, with skills for the SDK, input handling, font measurement and deployment. It encodes most of the mistakes above, so your coding agent doesn’t have to rediscover them.

Three builds in a week, and everything that broke

Once hello world worked, I built the two apps I actually wanted, plus a public build installed through the developer portal. The hardware forced me to measure everything I’d normally have eyeballed. Here’s what that looked like in practice.

MAGI: my agent, on my face

MAGI is a voice client for my own AI agent, which runs on a Mac mini at home. I named it after the three deliberating supercomputers in Neon Genesis Evangelion, because the header wrote itself: ◆ MELCHIOR ◇ BALTHASAR ◇ CASPER, 366 pixels wide, with room to breathe in 560.

About 990 lines of TypeScript. Speech goes to Deepgram, the text goes to my agent over a Tailscale tunnel, and the answer comes back to the lens.

The pipeline was the easy part. Scrolling was the hard part. I built pagination first, page 1 of 3, tap to advance. An hour later, Tom the user told Tom the builder: “Non mi piace lo scroll a pagine, lo voglio tipo infinite scroll.” I don’t like paged scrolling, I want infinite scroll.

Fair. Except there’s no viewport to move. So infinite scroll on glasses means breaking the text into exactly the lines the firmware will draw, measured with the real font, and keeping your own window over that array. A swipe moves one line. A tap moves half a screen. New text sticks to the bottom unless you’ve scrolled back to read.

I shipped it with a percentage indicator and immediately found a bug. At offset 7 of a 7-line document, it said 117%. I hadn’t clamped the cursor. On a phone you’d never see this, because the scroll container clamps for you. Here, you are the scroll container, and every affordance the browser gives you for free, you write by hand.

ORACLE: the app that listens, and four ways it lied to me

ORACLE listens to a live conversation and surfaces what’s worth knowing: factual errors, real numbers, the question you should ask next. About 1,551 lines. It works now. It didn’t work for most of the week, and every failure taught me something.

It was too polite. My first prompt had three instructions telling the model when to stay quiet and one telling it when to speak. So it stayed quiet. It let “only ten Esselunga in Italy” pass because nothing made speaking feel required. I flipped the burden of proof:

If the fragment names ANY concrete entity (a company, a place, a person, a number, a product) you MUST produce at least one element. Return an empty array ONLY if the fragment is pure noise.

And I added a test for every insight, written into the prompt itself: Tom reads it and knows something he didn’t know thirty seconds ago, or holds a question he can ask out loud right now. If it’s just a summary, discard it. Before that line, the model could pass by paraphrasing me back to myself.

I read four minutes of a sixteen-minute test. ORACLE kept dying after five to eight minutes. I looped 31 seconds of speech against Deepgram and watched the first four minutes. Minute four looked like a collapse. I wrote a diagnosis, built a fix, and felt clever. Then the full run finished:

min 0-3:   7, 7, 7, 6
min 4:     3           <- the only dip
min 5-15:  7, 8, 8, 7, 7, 7, 7, 8, 7, 8, 8

Nothing was collapsing. Worse, my “fix” would have cut the connection in the middle of every long sentence. The real bugs were boring: a missing .catch() that left a counter stuck forever, and request slots that never freed. I had real data and drew a confident conclusion from a quarter of it. The measurement didn’t protect me. Reading all of it did.

The fragments never arrived. In a long, fluent monologue, ORACLE transcribed happily and analysed nothing. The first final transcript came at 13.4 seconds, chopped mid-phrase. The documented fix (utterance end events) produced exactly zero events. So I stopped waiting for the API to finish my sentences, and harvested the growing partial transcript every 60 characters instead:

BEFORE:  9 analyses,  first at 13.4s, truncated fragments
AFTER:  13 analyses,  first at  8.3s, whole phrases

It billed me sixteen times for one conversation. My agent’s dashboard showed twenty sessions, sixteen of them created within the same minute, all with near-identical titles about the same topic. Two guards fixed it. A minimum six-second gap between analyses, chosen from the measured median interval of 4.4 seconds, not from taste. And a novelty check that drops any fragment repeating more than 70% of the previous one. Replayed on the real session, analyses went from 19 to 10.

Two things I got wrong in my own notes

Writing this up, I fact-checked my own assumptions, which felt appropriate for an article about a fact-checking app.

First, transcription. Deepgram turns “Esselunga” into “esse lunga” and “Tour Eiffel” into something creative. ElevenLabs got the proper nouns right in my batch tests, and I’d written it off because I thought it had no realtime streaming. It does. Scribe v2 Realtime has been out since November 2025, with sub-150ms latency and an EU data residency option. That’s my next experiment. Meanwhile, I tell the analysis model to reconstruct the most likely name instead of discarding the fragment, and it works. Read the verdict, not the transcript.

Second, calling models from the glasses. My Anthropic organisation refused browser calls outright, with an error citing its settings. I’d assumed that was universal. It isn’t: the API can accept browser calls with an explicit opt-in header. But you shouldn’t do it anyway. An API key inside an installable WebView app is readable by anyone curious enough to look. I routed through OpenRouter to get Claude with a proxy in between (200 OK in 3.2 seconds), and the grown-up version is a tiny proxy of my own.

What ten lines of green light teach a designer

This is the part I actually wanted to write. Designing for the G2 is less like designing an app and more like writing subtitles for someone else’s life. Here’s what changed in how I work.

Ten lines is the whole document

With a 27 pixel line height on a 288 pixel canvas, you get about ten lines. Not ten lines above the fold. Ten lines, full stop. Every line you spend on your app’s name, a timer or a counter is a line you took away from the person’s actual situation.

My first ORACLE layout had a session timer, a phrase counter, an analysis counter, a scrollbar and the app name. Four of ten lines were about the app. My own feedback, as the user, was one sentence: “secondo me il nome dell’app non serve sopra.” The app name doesn’t need to be up there. He was right, and it cascaded. The timer was vanity. The counters were debug output that had escaped into production.

The font lies, so measure it

My instinct was to make it beautiful. A cyberpunk HUD deserves shading blocks, the ░▒▓ ramp every terminal aesthetic leans on. I designed a gorgeous header. On the lens it rendered as a gap.

The firmware font simply doesn’t have those glyphs, and the renderer doesn’t complain. It skips them. So I asked the measurement library, and noticed that missing glyphs come back at a suspicious 4 pixels, while real ones measure 20:

glyph  px   verdict
  ░     4   missing from firmware
  ▓     4   missing from firmware
  ▀     4   missing from firmware
  █    20   present
  │    20   present
  ◆    20   present
  ◢    20   present

That’s not an official feature, and the library’s own docs warn that missing glyphs may measure oddly. But as a quick test, it has been reliable for me. The tactical triangles ◢◤◥◣ in my final header aren’t a style choice. They’re the survivors of a measurement.

The same goes for spacing. My scrollbar is a thin │ down the left edge. The glyph plus a space measures 25 pixels, so the text width constant in my code is TEXT_W = 535. Not 540, not “about 535”. The number came out of the font, not out of my head.

Subtitles, not dashboards

What replaced my first layout borrows from television, not software:

FALSO  Solo 10 Esselunga in Italia
  Oltre 190 punti vendita, ~9 mld ricavi. Nord e centro.

FALSO  Tour Eiffel vicino a Roma
  È a Parigi, Champ de Mars. 330 m, inaugurata 1889.
──────────────────────        analizzo
 e quindi il fatturato del gruppo quest anno dovrebbe
 superare i due miliardi secondo le nostre

Stable information on top, where the eye rests. The live transcript at the bottom, like subtitles. A rule in between, so you never confuse what was said with what the system concluded.

Moving text is visual noise. Put it at the top and it drags your gaze every second, so you read nothing. Put it at the bottom and you catch it in the corner of your eye, the way you follow subtitles in a film without deciding to read them. Academic work on reading with smart glasses, like Rzayev and colleagues at CHI 2018, points the same way: where the text sits matters as much as what it says.

A word beats a symbol at a glance

My first verdicts were symbols. A cross for false, a triangle for doubtful, a diamond for confirmed. My feedback to myself: “devi esplicitare FALSO.” Spell out FALSE.

A symbol has to be decoded. A word doesn’t. On a display you glance at for half a second in the middle of a conversation, FALSO lands instantly, while a cross asks you to remember what it means. I measured the longest label at 396 of 560 pixels. It fits, so it ships.

Without colour, hierarchy has to come from somewhere else. Position does most of the work, then spacing, then brightness. The SDK lets you set text brightness per container on a small scale, which is the closest thing you have to a secondary colour.

Silence is a feature

The hardest design decision on this device is when to say nothing. Every line that appears competes with the human in front of you. The reviewers who found Conversate distracting weren’t complaining about bad information. They were complaining about information at the wrong moment.

That’s why ORACLE’s six-second gap and novelty check aren’t just cost controls. They’re attention controls. And it’s why I think Even’s Terminal Mode is the most important pattern on the platform. It doesn’t stream your agent’s work at you. It shows a state (thinking, running, waiting), and only asks for you when a decision is needed. That’s how an agent should behave on your face: surface the state change, hide the process.

Input is one bit wide

Tap, double tap, swipe up, swipe down, long press. That’s the whole vocabulary, on the temple or the ring. You can’t build complex navigation on that, and you shouldn’t try. Design flows that work with the phone locked in a pocket, give every gesture a visible response, and make double tap mean “get me out” everywhere. Even’s review rules say exactly this, and they’re better design guidelines than most I’ve read for wearables.

Other people’s voices

No camera solves half the privacy problem. The other half is that ORACLE is, technically, a device that listens to everyone around me and sends their words to two companies. I’d rather say that out loud than pretend otherwise.

In Europe, this isn’t abstract. In May 2026 France’s CNIL published an alert saying smart glasses fall under GDPR whenever they process data about identifiable people. The EDPB has commissioned work on how socially acceptable these devices are, and Italy’s Garante has already raised concerns with manufacturers. Most of that attention is on cameras, but the logic applies to microphones just as well.

GDPR exempts purely personal or household use. Testing in my kitchen is fine. Running live fact-checking in a client meeting almost certainly isn’t personal use, and at that point whoever runs the app is handling other people’s speech, with everything that implies: a lawful basis, transparency, agreements with the transcription and model providers. I’m not a lawyer, and Italian rules on recording conversations you take part in are their own topic. So these are the rules I’m setting for myself, not a legal opinion:

• Say it before you use it. “I’m running live fact-checking on my glasses” is a slightly awkward sentence that makes everything else simpler.
• Don’t keep transcripts. Keep the verdicts that were shown, throw away the audio and the text.
• Pick providers for where the data goes, not just for accuracy. EU data residency and zero-retention modes exist now, and they should be defaults for this kind of app.
• Keep it out of rooms where it doesn’t belong. HR conversations, anything medical, anything where someone didn’t choose to be there.

There’s also a design lever here that I haven’t pulled yet. The SDK’s audio stream tags each frame with a guess about whether the speaker is the wearer or someone else. An app that only analyses your own voice by default, and asks before it listens to anyone else, would be a very different product. I suspect it would also be a better one.

Who should buy this

Most people shouldn’t, and I mean that as a compliment to the people who should.

Don’t buy the G2 if you want to take photos, listen to music, or replace your smartwatch. Don’t buy it for the stock apps alone, either. They’re good, not €699 good. And if polish matters more to you than possibility, wait a year.

Buy it if you’re in the trenches of making AI invisible. If you build agents and want to feel what supervising them from your peripheral vision is like. If you design interfaces and want a constraint that won’t negotiate with you. If you present, translate or live in meetings, and you want a quiet second channel that nobody else can see. Even’s own CEO has said about a third of its users are company executives. That tells you who this is really for right now.

The landscape around the G2 is moving ridiculously fast.

A year ago, “AI glasses” mostly meant putting a camera, microphones and an assistant into something that looked vaguely like normal eyewear. Now the category is fragmenting into several very different ideas of what a computer on your face should actually be.

Meta Ray-Ban Display sits at the more integrated end of the spectrum: colour display, camera, audio and a wrist-worn neural input device. At $799, it is probably the most obvious mainstream comparison to the G2, but philosophically they are almost opposites. Meta wants the glasses to see the world with you. Even deliberately removes the camera and tries to make the computer disappear.

Then there is a rapidly growing group of glasses much closer to Even’s idea.

RayNeo iO is particularly interesting. It weighs just 33 grams and combines a transparent heads-up display with features built around captions, meetings and AI assistance. This is no longer a speculative competitor — it is basically competing for the same “wear these all day and occasionally let AI put useful information in front of you” territory.

Halliday G2 goes after almost exactly the same design philosophy: lightweight glasses, a green display and, importantly, no camera. That last point matters because camera-free glasses are becoming a category rather than an Even-specific position.

Rokid Glasses take a different route. They keep the lightweight HUD idea but add a camera, giving software access to more of the wearer’s context. More interesting to me as a developer, Rokid has its own developer platform and SDK, opening up the glasses to experiences beyond whatever ships out of the box.

And then there is XREAL Aura — XREAL being the company formerly known as Nreal — which moves much further toward spatial computing. Aura runs Android XR, has a 70-degree optical see-through display, world-facing sensors and Gemini built into the platform. It is less “a notification in the corner of your vision” and more “an Android computer floating in front of you.”

That distinction is important.

The Even G2, RayNeo and Halliday are essentially asking:

How little computer can we put in front of your eyes and still make it useful?

XREAL and the emerging Android XR ecosystem are asking almost the opposite question:

How much computing can we move from your screens into the space around you?

And then there is a third category that I think might ultimately matter even more: open platforms.

MentraOS is an open-source platform and SDK built specifically around smart-glasses applications. Instead of treating the glasses as a closed accessory, the idea is to give developers access to capabilities like audio, displays and other hardware through a common application layer.

That changes the equation considerably.

My experiment happens to run on the G2, and I really like the G2 hardware. But the interesting thing I’m building isn’t really an Even Realities app.

It’s an agent that happens to have access to what I’m hearing and a tiny surface inside my field of view.

Today that surface is the G2. Tomorrow the same idea could run on another pair of glasses entirely.

And that might be the bigger story here.

The hardware is starting to commoditise.

Displays will get brighter. Batteries will get better. Cameras will get smaller. Frames will get lighter. Meta, Google, XREAL, Rokid, RayNeo, Even and a growing collection of smaller companies will keep iterating on the object sitting on your face.

But the more interesting competition may happen one layer above the glasses.

Who owns the context?

Who decides when to interrupt you?

Who remembers what you’ve seen, heard and discussed?

And can I bring that intelligence with me when I change hardware?

That’s why I’m less interested in building an AI app for a pair of smart glasses than I am in exploring what happens when my existing agent — connected to my notes, memories, projects and second brain — suddenly gains a persistent interface into the real world.

The glasses are just the display.

Theagentis theproduct.

What Even has that nobody else has combined yet: no camera, a display in both eyes, prescription lenses as a first-class option, and a web SDK you can use today. For someone building agentic experiences, that last part matters more than the optics.

Ten lines, measured

Every designer says they love constraints. We mean it the way people say they love running, as an idea, from a chair.

The G2 is a constraint that doesn’t negotiate. Ten lines. A font that silently eats half your glyphs. No scrolling you control, no colour, a microphone on a device with no place to run your code. You can’t art-direct your way around any of it. You can only measure, and then decide what earns its space.

What surprised me is how much of that measuring I wasn’t doing on screens. I’ve shipped design systems with spacing values that came from a feeling. I’ve approved layouts where the hierarchy was assumed rather than tested. The screen was forgiving, so I was imprecise, and imprecision hides easily in two thousand pixels.

Here, TEXT_W is 535 because the scrollbar is 25 pixels. The header uses ◢◤ because ░▓ don’t exist. The analysis fires every six seconds because the median gap was 4.4. Every number in my code has a measurement behind it, and the ones that didn’t are the ones that broke.

The glasses didn’t make me a more rigorous designer. They made it impossible to keep pretending I already was.

Ten lines. Measure them all.

Thanks for reading Sorted Pixels! This post is public so feel free to share it.