u/Far-Temporary6630

u/Different_Poetry_849 made another great one with Planes, point at an aircraft and get info about it in AR.

We’ve been doing a lot of location-based prototypes that use the camera, the world around you, and head movement. So for my PPP return, I wanted to try something a bit different: reading designed around a glanceable display.

I made Flow, an RSVP reading app for Meta Ray-Ban Display.

RSVP stands for Rapid Serial Visual Presentation. Instead of reading paragraphs, words appear one at a time in the same place. I first came across it through an Instagram Reel and thought it was a really interesting way of processing information.

It feels like a good fit for Ray-Ban Display because paragraphs can be awkward in a small field of view, but one word at a time feels surprisingly natural.

Personally, I can read RSVP at 450+ WPM when focused. At around 300 WPM, I can still do other things while reading, which is the part I find most interesting.

Right now I’ve been testing it with daily news, stocks, a few public-domain books like Alice in Wonderland, and language switching. I did some research and RSVP does seem to work in other languages too, although English is by far the most researched.

Curious what people think:

Would you use something like this for news, articles, books, docs, or messages?

Is the value speed reading, hands-free reading, accessibility, or making glanceable displays more useful?

What features would make it actually useful?

🏓 For context: u/Different_Poetry_849 and I both got Meta Ray-Ban Displays, so we started Ping Pong Prototyping. One of us ships an app, then it’s the other’s turn to return.

This is my return to Planes, ball’s back on their side of the table.

I’ll put the demo link in the comments.

Returning my serve, u/Different_Poetry_849**. 🏓**

Nice hike. Smart glasses that name mountains for you, very civilized.

Me? I stayed indoors and taught my glasses to throw sharp objects.

I linked the Meta Ray-Ban Displays to my Scolia Home 2 dartboard. The board already auto-scores every throw, so I figured: what if each dart could do something? So I built a little suite of minigames that live right in the display while you play:

• 🪨 Asteroid — every dart chips away at a rock hurtling toward you. Miss, and it gets closer.
• 💣 Bomb Defusal — hit the right segments in the right order before the timer runs out. Wrong wire, boom.
• ⭕ Tic Tac Toe — the board becomes the grid. Land your dart in the square you want.
• 🔐 Safe Crack — dial in the combination, one throw at a time.

There's also a guide built in to get you started.

These are first prototypes, mostly to answer a question I was curious about: how does it feel to play with a non-spatialized display? The MRBD HUD isn't full AR — it's a little heads-up panel, not anchored to the world. My honest takeaway: it works better than I expected. It definitely makes darts more playful. Having the game react in your periphery while you focus on the board is a surprisingly good loop.

Super big thanks to Scolia for partnering with me on this one! It all runs on their board and their API — the real-time throw detection is what makes these games possible in the first place. Couldn't have built it without them.

Lots more to come. Your turn, and no hiding on a mountain this time. 😄

🏓 For context: A friend and I both got Meta Ray-Ban Displays, so we started Ping Pong Prototyping (PPP). Every day, one of us builds something for the glasses, then it's the other's turn. Liam went hiking and served, so this is my return.

Learn darts by playing, not by reading. On a real board, in AR.

Learning darts means throwing a thousand darts at a wall and hoping you improve no feedback, no tracking, no progression. Online guides aren't fun. We wanted to kill the manual for a hobby millions share, and use AR to coach the way a real instructor would while opening darts to newcomers through social play and mini-games.

DartsMate turns any throw on a real dartboard into instant AR coaching and games. The board sees every dart; the glasses turn it into an experience — target highlights on the real board, live scoring, a coach in your ear, a shrinking heat map of where you land, and eleven mini-games that make practice feel like play.

Our first version proved the AR magic worked. The feedback was clear: judges loved how it blended the physical board with digital coaching, but the phone-camera computer vision was the friction — fiddly setup, lighting-dependent detection, hard to scale past a demo. So we went and fixed it at the source, i contacted Scolia and they loved the demo, so i flew off to Hungary to meet them and try their products before XRCC.

How Scolia solved the hard part- The single biggest change: we replaced our phone + OpenCV pipeline with a Scolia auto-scoring dartboard — commercial venue hardware with three built-in cameras and on-board image processing. This erases every CV hurdle the judges flagged:

- No phone, no tripod, no lighting-dependent OpenCV, no 4-dart calibration. The board is a fixed install that already sees the whole surface.

- Professional-grade detection, instantly. We connect to Scolia's WebSocket Social API (wss://game.scoliadarts.com/api/v1/social) with the board's serial + access token and receive a live stream of every event: exact sector (T20, D16, Bull), millimetre coordinates, bounce-outs, and takeout detection — in real time, unchanged.

- Venue-ready by design. Because detection lives in the board, DartsMate runs on any Scolia-equipped venue — sports bars, leagues, training centres — with zero per-session setup. That's the jump from "controlled demo" to "scalable product."

- The phone is now optional. It's only used to add player names and photos before a game; it plays no part in detection. Throws flow board → Scolia cloud → glasses on their own.

In short: the thing that made the demo cumbersome is gone, and what replaced it is the same technology real venues already run.

Features

- Real auto-scoring board — every throw detected by Scolia, streamed to Spectacles in real time (sector + exact position).

- AR target highlights & hit markers painted onto the real board through Snap Spectacles.

- Coaching mode — structured Learn / Drills / Free Play, with smart feedback ("Right number, wrong ring!", "Just a bit clockwise") and ElevenLabs voice coaching that reads it aloud.

- Live heat map in Free Play — see exactly where your darts cluster, tighten over time.

- 11 mini-games — Learn the Board, Drills, Free Play, Tic-Tac-Toe, Asteroid, Stay in Zone, High Noon, Shanghai, Bomb Defusal, Heist, and Physics Bounce — each a different way to build real aim.

- In-lens "?" help that explains any game on demand, spoken and on-screen.

- Wall-placement — drop the whole AR rig onto your real board's surface and play.

- Multiplayer, it all seamlessly works with multiplayer, set how many players, enter names and ti handles the turns.

How we built it

- Detection: Scolia Social API over WebSocket — real dart events, no CV of our own.

- Bridge: a lightweight web companion handles the player roster and relays board events to the glasses (one Scolia connection fans out to every headset).

- Spectacles (Lens Studio 5, TypeScript): DartBoard is the single source of truth; every game listens through one onDartLanded callback. SIK for hand tracking, procedural meshes for effects (bomb wires, the heat-map grid), and ElevenLabs TTS for the coach.

- Robustness: we handle the board's real-world states — takeout phases, one-connection-per-board, auto-recovery — so a live venue session doesn't stall.

What's next

- Form analysis using the Spectacles forward camera (grade the throw, not just the result).

- LLM-powered personalized coaching on top of the voice coach.

- Tournament mode with turn-locking for ranked, multi-board play.

- Venue & licensing — DartsMate as an AR layer any Scolia venue can switch on, plus more games (Battleships, Zombies, Around the World).

On the video i think it looks like some of it is hard to see but on the device its much more visible! But i do think theres UX work to be done here need some testers!

Will continue to work on this, so if anyone has some crazy idea for a Phygital darts game let me know!

Also super big Thanks to Scolia for partnering with me on this one!

Whenabouts is a Spectacles AR lens that turns your real location into a prehistoric discovery game. The idea: point your glasses at the world around you and uncover the creatures that once lived right where you're standing, with an AI guide narrating each find.

I've done a lot of travelling this month, and I've been stabbing at this idea for a few months now. Prototyping and developing it across all these different locations has been so much fun, because you actually learn about the ancient animals that lived where you are. My favourite moment: I was testing in California and barely any dinosaurs were showing up. I thought I'd hit a bug, dug into it, and it turns out it wasn't a bug at all, that part of California was underwater. It was an ocean. The game taught me something real about a place I was standing in, which is exactly the feeling I'm chasing.

The part I'm most into is that it's grounded in real data. It pulls fossil-occurrence records from the Paleobiology Database (PBDB) based on your GPS location, so the creatures you dig up are genuinely tied to your area's deep history, not randomly generated. An AI narrator brings each one to life (Gemini for the text, ElevenLabs for the voice), and you build a personal collection over time. Accessibility was a priority throughout: spoken narration, a kids mode, and multiple languages.

The modes:

• Uncover: find creatures right where you are, no walking to spots required. There's a "?"-until-found discovery beat, then a Top Trumps-style card pops in.
• Explore: a map with dig-site markers you physically walk to.
• Codex: an infinite, swipeable fan of cards for everything you've collected. Tap a card to spatialize the creature into your room.
• Play: solo Top Trumps using your collected creatures.
• Multiplayer: two-player head-to-head Top Trumps over Supabase.

A bit more on the two ways to discover, and why it matters

There are two ways to find creatures. In Explore mode you walk to dig-site markers on a map, the classic get-out-there loop. In Uncover mode you don't have to travel anywhere: you access the creatures from right where you are. Either way, every creature is a ? until you discover it, and once you've found one yourself it's marked as found in your Codex. So Uncover isn't a cheat, it's a parallel path to the same collection, and the creatures you personally uncovered stay flagged as yours.

That no-walking path is a deliberate accessibility call, and it's worth saying what I mean by accessibility here. Pokémon Go is the obvious reference point: during the COVID-19 pandemic, Niantic implemented changes and new features allowing players to play remotely more easily, most famously doubling the interaction radius so players could explore from a distance. That change benefited alot of users, both with disbailities and without i.e. it helped rural players who may not have many points of interest nearby, and players who can't physically or safely access certain locations. The lesson Niantic learned the hard way, and kept reversing and reinstating, is that forcing in-person play locks people out.

So accessibility here isn't only about disability. It's also for the parent with a small child who can't roam a city on foot, the person who genuinely can't afford to fly to a dig site in Mongolia or a museum in Japan to encounter a particular creature, or anyone with a busy life who only has ten minutes on the sofa. The walking loop is there for people who want it; Uncover makes sure nobody's deep-time backyard, or anyone else's, is gated behind their mobility, budget, or schedule.

On the visuals: the AI image generation is doing something specific. It blends the creature's world with your world. Rather than dropping a clean museum render on top of your room, the generated image fuses the prehistoric environment the creature lived in with the real space you're standing in, so a Cretaceous riverbank bleeds into your living room and the creature reads as belonging to both at once. That's the whole fantasy of the lens in one image: this thing was here, in this place, a very long time ago.

• Cards are Top Trumps panels with AI-generated stats (weight, era, deadliness, intelligence, cuteness, mystery) and either a saved generated image or a PhyloPic silhouette.
• Habitat spatializes a creature's AI-generated image into your physical space. Had to add downscale rigs and request throttling here, since concurrent AI calls were crashing the device.
• Supabase backend: a shared card catalog plus a private per-user collection, with Snapchat-identity auth and row-level security so each player's images stay theirs.
• A persistent narrator panel carries prompts, results, XP/levels, and feedback.
• There's also a semantic LLM sort, so you can ask stuff like "show me something that would've eaten my friend" and it works.

For the multiplayer: the network layer runs a create/join-by-code lobby and syncs turns by polling a Supabase table (~1.5s its turned based so we can have some latency), and it drives the existing solo board rather than duplicating the UI, so online plays exactly like single-player: choose your card (opponent hidden), pick a stat, reveal both and hold, winner keeps the turn, all spoken by the narrator.

An animated guide, deeper settings, and a social hook

An animated archaeologist character guides the experience, a proper on-model companion rather than just a disembodied voice, bringing the discoveries to life as you make them. I purposley chose a British voice as it reminded me of home!

The settings run deep too: language options, and voice playback speed so you can slow the narration down or speed it through, which ties back into the accessibility thinking, since speech pacing matters a lot for different players. And ofc everything has subtitles.

And the bit I'm most pleased with: it's quietly social. When you play Top Trumps with friends, you each see the moments the others captured out in the world. The image you took when you uncovered a creature gets stamped onto your card for it, so your deck is personal: your Triceratops shows the spot in your neighbourhood where you found it, your friend's shows theirs. Playing a hand isn't just comparing stats, it's sharing where and how you each met these creatures. The collection becomes a record of your own expeditions, and the card game becomes a way to show them off.

Kids mode:

There's a dedicated kids mode that changes how the content is generated, not just the UI. When it's on, the AI is steered toward safer, age-appropriate output, and the image generation goes more cartoonish and friendly rather than realistic or intense (no gory deadliness, no nightmare fuel). It also leans toward well-known, recognisable animals, the crowd-pleasers a kid actually wants to find, instead of reaching for the obscure deep-cuts, and keeps things less expansive so younger players aren't overwhelmed by walls of detail. The goal is that a parent can hand the glasses to a child and trust both what shows up and how it's framed, while the same engine still serves the full experience for everyone else.

On onboarding:

In the past I've moved fast and shipped things that made total sense to me and nobody else, because I forgot to actually onboard the player. This time onboarding is built right into the AI narrator. The same voice that gives you hints about creatures also walks you through how everything works, from navigating the menus to what each mode does. There's no separate tutorial wall to sit through; the narrator just guides you as you go, so learning the lens and playing it are the same thing. It also means onboarding inherits everything else the narrator does: it's spoken, it respects the playback-speed and language settings, and it gets gentler in kids mode.

On keeping AI costs sane:

One thing I had to solve early: doing all of this with live AI calls would be brutally expensive and slow, especially TTS. Now thankfully Snap give us api keys but the ElevenLabs is my own and that voice generation is the priciest part, so I don't generate everything on the fly. Instead I cache aggressively. Common phrases and the narration the player hears constantly (UI prompts, the archaeologist's recurring lines, result callouts, onboarding) get generated once, downloaded, and stored, then played back from cache instead of re-synthesized every session. Same idea on the broader AI content side: anything that doesn't need to be unique per-player gets generated ahead of time and reused, so live generation is reserved for the genuinely one-off stuff, like a specific creature's narration or image the first time it's discovered.

The payoff is threefold: way fewer tokens and TTS characters burned, much lower latency (cached audio plays instantly with no API round-trip), and better reliability on-device since you're not hammering the network mid-experience. It's the same instinct behind the request-throttling and downscale rigs I mentioned for Habitat: on glasses, the cheapest and fastest call is the one you already made once and saved.

Lots still i wanna do on this one,
Thanks

Liam

Meta Geology had me at "dig beneath your feet." Taking the bedrock you'll never actually see and turning it into something you can hold and collect is such a good use of where you're standing. So when I started thinking about a return volley, I wanted to keep that core move: take something invisible right around you and make it physical. Meta Geology drills down into the ground. I figured I'd go the other direction, into the air you're literally breathing right now.

But I'm not really a rocks-and-minerals person, and there was no way I was out-mineraling a mineral app...

Meta Geology: https://www.reddit.com/r/MetaRayBanDisplay/comments/1ucdunx/i_built_meta_geology_it_lets_you_dig_into_the/

Then it hit me. With all these location-based apps, we keep uncovering what's around us (history, geology, the cool stuff underfoot) but we tend to skip the stuff that can actually harm us. The things in the air don't announce themselves: no smell, no color, no number floating in front of your face. So I decided to build the feeling, not the number.

Meet AirMeter.

It pulls live PM2.5 and NO₂ for wherever you're standing and gives you a plain-language read, Good through Extremely Poor, instead of a value you have to decode in your head.

The bit I'm happiest with: there's a drifting particle field floating in front of you that gets denser and heavier the worse the air actually is. Clean air = a few faint specks. Standing in Delhi-level pollution = a thick, slow haze closing in around you. You kind of feel the air quality instead of reading it.

Swipe between Air / Pollen / UV / Compare, and tap any of them for a 7-day trend and the best time to head out.

Try it here: https://airmeter.vercel.app/

🏓 For context: [a friend and I both got Meta Ray-Ban Displays, so we started Ping Pong Prototyping (PPP): every day one of us builds something for the glasses, then it's the other's turn.] This is my return volley for u/Different_Poetry_849's

Ball's back on your side of the table. Your serve 🏓

How clean's the air where you're standing?

Meet Whenabouts

While u/Different_Poetry_849 was out solving the genuinely critical problem of locating the nearest pint of Guinness - https://www.reddit.com/r/MetaRayBanDisplay/comments/1u9lis9/pure_utility_find_nearby_irish_pub_easy/

I pointed my Meta Ray-Ban Display at the ground and asked a different question.

Whenabouts asks when. It's a location-based window into deep time. GPS finds where you're standing, and the glasses surface the real prehistoric creatures whose fossils were actually dug up near that exact spot, one at a time, like your uncovering them yourself. Swipe to the next find. Walk somewhere new, get new ground.

Under the hood:

• GPS for where you are
• Paleobiology Database for the real fossils recorded nearby, actual data.
• PhyloPic for the silhouettes (This was an amazing find, millions of silhouettes of creatures perfect for a 2d interface), with a procedural glowing-wireframe fallback that reads beautifully on a see-through display.
• Gemini for LLM understanding, get facts, ask questions learn about the creature beyond its name and when it was around.
• ElevenLabs for the voice - narration, creature roars, and a scanning hum. With millions of creatures ELevenlabs is great at creating sound effects on the fly.

Try it here - https://whenabouts.vercel.app/

APIs are on a free tier/ limited so if your missing audio or some fact generation that'll be why!

Context: my friend and I both just got Meta Ray-Ban Displays, so we've started Ping Pong Prototyping (PPP), every day one of us develops something on the glasses, then it's the other's serve. He opened with Nearby Irish Pub. This is my return.

I uploaded Wibble a few weeks back, but being a solo developer it was hard to record the multiplayer! I finally got to show it to some friends at AWE, and it's a lot of fun to see it working.

The new specs announcement has me excited for these colocation games that bring the game into the world while making it social there's something funny about throwing imaginary creatures at your friends. Having glasses on grounds it in the world, and effects that interact with your real surroundings ground it even further. That's a kind of magic you can only get with glasses.

One issue I've always found with using XR in public is that it draws attention to you doing gestures and the like can come across as weird. But doing it with a friend makes it a whole lot less awkward.

I've kept the video raw so you can see it actually works. Sure, there's some latency and a few issues, but multiplayer experiences like this aren't hard to make and iterate on.

Been working on a slime game for Spectacles this month called Wibble and figured I'd share where it's at.

So i shared a previous post a few weeks back and the idea has developed a fair amount since then.

The aim was to make a toy first. A lot of stuff I've made before looks cool but isn't really spatial, it just sits in front of you, on sits on something virtual. I wanted this to actually live in your room, in your world. You summon a slime to your palm, pinch and pull it back like a slingshot and let go, and wherever it lands it melts onto that surface, floor or wall or whatever it hits and makes a satisfying ripple effect. I like to think its like throwing a ball you never have to go pick up, or a fidget toy for spectacles. Honestly just launching slimes around the room and watching them splat is fun on its own, there doesn't really need to be a game, the game is just an excuse to keep doing the thing that already feels good.

The game itself is dead simple, collect as many orbs as you can. Each pinch and pull is a turn and orbs only live for a certain number of turns, so you've got a limited budget of shots and you're choosing what's worth going for before it disappears. The orbs spawn with World Query so they pick real surfaces in your space, and they're scored by difficulty, an orb high up on a wall is worth more than one on the floor. Because it's all on the world mesh every environment plays differently, your room, your office, a mate's place all give you a totally different layout of easy and risky shots. The space basically is the level.

My biggest take away from the specs dev day was Blendshapes! Ive always loved jiggle in games and ive always done it with physics i didnt think about blendshapes and it turned out to be a very good choice! I used to use chain controllers, spring joints and for VR it can be fine, but blendshapes ended up more optimised and way easier to control. The wobble, the menus, the orbs, all blendshape driven now. I went a bit crazy with them honestly.

I also tried my hand at shaders something i tend to stay away from. The melt effect was a tradeoff. To get it looking right and not torn I had to push the slime to around 6k verts. That still runs at a solid 60fps so it's fine, but I do have a leaner version of the base wobble at about 300 verts with blendshapes, and if I dropped melt entirely I could have loads more slimes on screen at once. I decided to keep it. These are hero objects, 6k isn't much for a hero, and the melt working on any surface it touches just adds that bit of extra juice. Also all the models share the same UVs so textures drop onto any of them with no rework, which is what makes the store actually practical.

It's multiplayer too. Uses SyncKit with a co-location. The bit I'm happiest with is players see each other's equipped cosmetics. Instead of syncing every cosmetic over the network each slime just broadcasts a tiny id and every client pulls that player's equipped items and applies them locally, so your custom slime shows up right on your friends headset and theirs on yours.

I also added an onboarding tutorial after demoing at a few events this month, including the AR/VR expo in Shanghai. Two things stood out, a lot of people didn't get the Spectacles interaction at all, and I kept having to explain how to play. So the tutorial uses animated hand meshes that make you actually do the action before it moves on, no reading.

For the store I'm using Supabase and it's made setting up a big cosmetic system really easy. Right now there's around 500 models, 20 textures and 6 animated eye sets, which is a huge number of combinations. I've always liked the Fall Guys approach to cosmetics and I think a store with in game currency is a great way to add replayability.

Stuff I want to do next, a spatially aware mode using a Gemini depth cache, a story layer, shockwave colours and more particles, more customisation to make the slimes feel even more alive, and longer term using Wibble as a base for quick replayable Mario Party style mini games with cute characters that are easy to pick up and easy to make multiplayer.

One thing I keep going back and forth on, is the melt worth the vertex budget or would you rather have a screen full of lightweight wibbles?

Maybe ill do a voiceover or another video in the week, its very late!

Im also going to be sharing a broken down version of it as open source. Just need to strip my supabase logic.

Try it here- https://www.spectacles.com/lens/84052185fd864a5bb0883bfab761fbfa?type=SNAPCODE&metadata=01

Thanks,
Liam

I've always liked adding feel to games, and I always lean towards jiggle. This month I'm trying to do a more optimised version. Before, I did it with chain physics with iyo roll - it worked and for one object this was okay, but we can always thinkmore about optimisation, so I've taken a look at blend shapes to drive the jiggle.

I also want to create truly spatial experiences. What makes mixed reality cool is that it's not just a level you can see in your world, it actually interacts with your world. So I'm getting out of my comfort zone, inspired by Hot Air Hero (https://www.reddit.com/r/Spectacles/comments/1rgfnuk/hot_air_hero_pilot_a_3d_hot_air_balloon_through/) - using World Query and messing around with shaders to create a shockwave effect that bends around your actual environment.

The slime also predicts what surface it's about to hit mid-flight and rotates so its base lands flush against it. So when it splats, the melt happens on the actual surface, floor, wall, ceiling, the angled side of a couch, whatever you hit. The geometry of your room becomes part of the deformation (to a degree!)

Still lots to do, but I thought I'd start sharing these experiments as I go.

Not the usual post… This month I thought I’d try something new.

I’ve always got too many ideas and I can never pick between them, so I’ve decided I’m not going to pick anymore.

I’ll let something else handle it. More advanced than any AI system.

Deploy rabbit- Observe selection- Commit.

He already controls most of my personal life anyway, so it was only a matter of time before he took over my professional life too.

BullsAI turns any dartboard into an AR coach and gaming platform. A phone watches the board through computer vision and detects every dart in real time. Spectacles overlay coaching prompts, target highlights, and games onto the actual physical board. .

The phone is the input device. Mount it on a tripod, run the webapp, and OpenCV handles detection, HSV colour masking finds the board, ellipse fitting locates the centre, and a 4-dart calibration locks in a perfect perspective transform from any camera angle. Player places darts at Double 20, 6, 3, and 11. Four known points on a circle yield a matrix that maps the camera view to ideal board coordinates. The simplest solution beat every clever auto-detection approach I tried. Detection runs every 200ms with position-based deduplication so the same dart never sends twice, only when it actually moves more than 4% of the board does it trigger a new event. Pull the dart out, throw another, the next one fires immediately.

The Spectacles app is built around a single input system. Communicating with Supabase, listneing to dart events. Every game is a self-contained TypeScript file that subscribes to a callback and reacts. Adding a new game is one new script plus a button in the lobby.

Ive made 5 games modes as is; Dart Assist is the coaching mode: structured lessons on board layout, throw technique, and 12 progressive drills with smart feedback after every miss. The feedback isn't generic, it analyses the actual drift vector between target and dart, then gives technique advice. "Pulled hard right, relax your grip and throw straighter." "Right number, pulled inside. Trust the throw, aim slightly outward." "Drifting right, tighten your wrist on release."

Bubble Pop is Puzzle Bobble but on the dartboard. 12-20 bubbles spawn in clusters around the rim in three colours. Your dart is assigned a random colour each throw, only matching bubbles pop. Hit a cluster and a flood fill finds every connected same-colour bubble, then they all burst outward with explosive physics, gravity, and spin. Score is bubbles cleared per dart taken.

Apple on Head is William Tell a Bitmoji holds an apple, hit the apple to launch it sideways with physics, hit the face and the Bitmoji shakes.

Tic Tac Toe runs on a 3x3 grid mapped to the board with cell takeover (land on opponent's X and it becomes your O), auto-resets after wins.

Free Throw is a heat map every hit position spawns a marker so you can see your shot pattern build up.

Multiple Spectacles can join the same game code and see darts in sync. Multiplayer is "shared view" right now, both wearers see every dart, both react, but each runs its own game state. Proper turn-locking is on the roadmap.

Supabase powers the entire backend. Two tables dart_games for sessions and dart_throws for individual hits. Phone writes detections, all Spectacles read. No custom server, no socket setup, just polling at 200ms.

A reactive slime-face character watches every throw and reacts with surprise on bullseyes, sad on misses, and idle blinking the rest of the time.

Optimisation: detection on the phone, rendering on Spectacles. The Lens itself runs lean because the heavy CV work is offloaded entirely. Every game uses object pooling for spawned markers, the slime face is unlit shaded, and the dartboard reuses a single anchor disc that all game prefabs parent to.

I know having to set up a phone as the camera is awkward, that part isn't where this is meant to live long term. The thinking is BullsAI works best at venues. Some pubs and bars already have cameras around their dart boards, and Spectacles can potentially pair with that existing setup so the player just walks up, puts the glasses on, and it works. The phone is the dev kit. The venue install is the product.

I've actually built something in this direction before. A few years back I worked with a company in the UK called Axed making smart lanes for axe throwing. Object tracking was rough at the time so we shipped projectors and tablets instead of AR, but the principle was the same: take a traditional physical sport and layer a digital counterpart on top of it. Scoring, games, leaderboards, all driven by what's actually happening on the target. AR finally makes that experience personal instead of shared on a screen, and Spectacles are the right form factor for it.

Looking ahead, voice coaching with ElevenLabs, form analysis using the Spectacles forward camera to grade throw motion, LLM-powered personalised coaching that learns your weak zones over time, more games (Battleships, Around the World, Zombies), tournament mode with proper turn-locking, and safety warnings using depth sensing if someone walks in front of the board.

Was a tonne of fun building and showing this off at the Spectacles bootcamp.

Ive also submitted to the XRCC hackathon- "Kill The Manual".

Repo: https://github.com/ohistudio/BullsAI

Try the phone detector live: https://ohistudio.github.io/BullsAI/web/darts.html

Lens Link: https://www.spectacles.com/lens/e2cccc74d86949fc84ea5f084188a5df?type=SNAPCODE&metadata=01

Trailer: https://www.youtube.com/watch?v=wr63v62yR7k