DEV Community: Gavin Rose

Plinth! My first arcade-style game.

Gavin Rose — Sat, 10 Oct 2026 23:58:37 +0000

I just shipped Plinth, a small one-tap arcade game for Android. You stand on a column, a new column rises next to you, and you tap to stop it, ideally at your height. If you stop it too high, the extra gets sliced off, so every column after that is shorter. Stop it too low and you fall.

👉 Get Plinth on Google Play · plinth-mobile.web.app

It's built with Flutter and Flame. Here's the story!

Faking 3D to promote performance

Plinth looks 3D, but it's plain 2D canvas drawing. Every column is a box in isometric projection: three filled polygons (top, left side, right side) computed from grid coordinates.

The only real trick is draw order. Boxes further "back" have to be painted first, so each frame I sort everything by gx + gy and paint back to front (the painter's algorithm). The player gets drawn last, except when falling into a gap, where it slots into the sort so the columns in front correctly cover it.

Game feel is a pile of tiny things

The first playable version worked but felt dead. What fixed it was a slew of small touches, none of which were too hard to implement...

Manipulating the character on the character: a little crouch before a hop, a stretch in the air, a squash on landing.
A rising chime for perfect stops that climbs a scale with your streak, so a streak of perfects sounds like a melody.
Screen shake and debris when a column gets sliced.
A "NEW BEST!" moment mid-run whenever you beat your previous best score, complete with confetti.

All of the sound effects were generated with a short Python + numpy script (sine waves, envelopes, some filtered noise).

Syncing coins across devices without a backend

I wanted coins and unlocks to follow players between phones, without running a server. Google Play Games' Saved Games stores a blob per player for free, so I only needed a merge strategy for when a local copy and the cloud copy disagree.

A plain "take the max coins" merge is wrong: spend coins on one phone, sync an older copy, and you get the coins back. Instead, coins are stored as per-device running totals of earned and spent:

Each device only ever increases its own counters, so merging is just "take the max per device". Owned items merge as a union.

The rejection that taught me to test release builds

My first production submission was rejected: "Plinth keeps stopping." It had never crashed for me once. Here is where I used Claude Code to find a quick fix.

The cause: release builds run R8 (code shrinking), debug builds don't. The ads SDK pulls in an old version of WorkManager, which uses Room, which finds its generated database class by name at startup. R8 renamed it, so the app crashed before drawing a single frame:

Failed to create an instance of androidx.work.impl.WorkDatabase

The fix was a keep rule plus a newer WorkManager:

# android/app/proguard-rules.pro
-keep class * extends androidx.room.RoomDatabase { <init>(); }

// android/app/build.gradle.kts
dependencies {
    implementation("androidx.work:work-runtime:2.11.2")
}

The real lesson: before every upload, install a release build fresh on an emulator and actually play it. flutter run in debug mode tells you nothing about R8.

While testing that, I found a second problem: on a phone with no Google account signed in (like many review devices), my startup code triggered the interactive Play Games sign-in, which opened Google's full account login screen. Now the app only silently checks sign-in status at launch, and the interactive flow lives behind a "Sign in" button on the leaderboard.

Two small gotchas worth knowing

AdMob's app-ads.txt check vs Firebase Hosting. firebase init offers a single-page-app rewrite that sends every unknown URL to index.html with a 200 status. That means /app-ads.txt "exists" but returns HTML, and AdMob reports a mismatch. Use real files with cleanUrls and no catch-all rewrite.
The consent form is not optional in the EU and UK. Google's UMP SDK ships inside google_mobile_ads. Request consent before initializing ads, and add a "Privacy options" entry so players can change their choice later.

Monetization: rewarded only

Every ad in Plinth is opt-in: continue a run once, double your coins, or earn coins in the shop. No banners and no interstitials. It earns less per player than forced ads would, but I'd rather people keep playing than bounce off an ad between every run.

Try it

Plinth is free on Android: Google Play. If you give it a go, I'd love to hear your best score, and any feedback on how it feels. And if you're building something similar in Flutter and Flame, ask away in the comments.

Rockhounds should try this!

Gavin Rose — Sat, 10 Oct 2026 23:05:47 +0000

Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass Submission 🌿

Gavin Rose

Oct 10

Pocket rockhound buddy that works anywhere

#devchallenge #hf26challenge

8 min read

Pocket rockhound buddy that works anywhere

Gavin Rose — Sat, 10 Oct 2026 14:27:51 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

I love to explore nature, and while I'm familiar with the minerals, fossils, and stones around my area, I wanted something that could help people that may not know as much, and more importantly, something that could be used completely offline so that it would still work even if you are far into a trail.

The idea is that a photo alone isn't normally enough to identify a rock, and even using flagship close models like gemini can give mixed results. There are several tests you can perform at the site or at home such as scratching it, weighing it in their hand, or putting vinegar on it to see if there is a reaction. This app takes a photo for a first guess, then walks you through those same physical tests one at a time:

Can your fingernail scratch it? A coin? A nail?
Rub it on an unglazed tile. What color is the powder?
Does a magnet stick to it?
Put a drop of vinegar on it. Does it fizz?
Is it a shell with two halves? Is each half symmetrical?

Each answer updates the odds, and the app always asks whichever test will narrow things down the most next. Most identifications take 5 to 8 tests. Between questions the phone is in your pocket and the rock is in your hand, which is the part I like best: the screen is the shortest part of the experience.

The model knows 94 things: 53 minerals, 22 rocks and 19 fossils. It also knows where you're standing. It looks up the bedrock under you from open geologic map data, so in limestone country it leans toward calcite and crinoids, on granite toward feldspar and mica. It even knows the age of the rock. A trilobite can't turn up in rock that's 100 million years too young.

When you're done, you get a specimen label (type, hardness, streak, where to look for more) and can save the find with its GPS location. Finds export as GeoJSON, so you can map everything you've found if desired.

It's for anyone who picks up rocks on a hike, at a creek or on a beach and wonders what they're holding. That covers kids, rockhounds, and people like me with pockets full of crinoids.

Demo

Try it: [https://blue-math-567b.gavin-rose.workers.dev/]. Open it in Safari or Chrome on your phone and add it to your home screen. The first launch downloads the model (about 63 MB, Wi-Fi is recommended). After that, it works wherever you go! While a connection is available, it will use a larger hosted open weight model to give better results more quickly, and will fall back to the lightweight model when necessary or if you toggle the other one off.

I took it outside

I went out on a few walks near home, where the bedrock is shale and sandstone, and here's how it went.

Crinoids, three different ways. Loose stem discs in my palm: crinoid stems, 92%. A stem lying along a rock face: 87%. A slab of fossil hash: 88%. Each one took about five tests.

It got things wrong too. A small white chip came back as calcite, and it wasn't. One find only reached 19% for "conglomerate", which is really a shrug dressed up as an answer. And when I photographed nothing to test the app, it confidently named a rock anyway.

It crashed. On my iPhone the app downloaded the model, then Safari killed the page. In the field I had to time my taps to get in before it went down.

The questions felt off. The fossil-shape question ("stacked discs? coiled shell?") kept coming up before anything suggested a fossil, so for most rocks I was tapping "None of these".

Every one of those turned into a fix, covered below. Taking it outside was the most useful testing I did.

How I Built It

It is an installable web app (PWA) written in TypeScript with Vite. There's no app store and no account. The AI runs directly in the browser.

The photo model: SigLIP 2, on the phone

The photo step uses SigLIP 2, Google's open-weight image and text model, running fully on-device through Transformers.js and ONNX Runtime Web. On phones it runs as a 4-bit model (63 MB) on the CPU. On desktops with WebGPU it uses the fp16 version on the GPU.

I didn't start with SigLIP. I started with CLIP, then benchmarked five open backbones on the same images and the same held-out split, training the same small classifier on top of each:

Backbone	Top-1	Top-3
CLIP ViT-B/32 (where I started)	43.5%	61.9%
CLIP ViT-B/16	48.6%	66.3%
DINOv2 small	47.7%	62.4%
DINOv3 small	51.2%	67.0%
SigLIP 2 base	56.0%	72.9%

SigLIP 2 won clearly, at the same 63 MB on the phone. Swapping it in took about an hour. That's only possible because every one of these models is open and runs in the same runtime.

Training it on rocks

Off the shelf, SigLIP 2 manages 29% top-1 across all 94 classes. I trained a small classification layer on top of it, using about 5,000 openly licensed images:

Wikimedia Commons: Creative Commons photos of minerals and rocks, with attribution saved for every file.
GBIF: CC0 and CC-BY photos of fossil specimens from natural history museums. These were the key to fossils, including plenty of the loose crinoid discs I actually find.
My own field photos: always trusted and never filtered.

Web data is messy. A search for "granite" returns mountains, statues and kitchen counters. So the training script uses the model itself as a filter: it drops any image that looks more like a landscape, building or diagram than a rock specimen. Museum photos had the opposite problem: a tiny fossil next to a big ruler and a color card. For those, the script tries a grid of crops and keeps the one that looks most like a fossil and least like a ruler.

The trained model gets 62.3% top-1 and 78.6% top-3 on held-out images, up from 29% and 45% for the untrained model. Top-3 matters most, because the photo is only a starting point and the physical tests do the rest.

The tests: odds that update with every answer

Each of the 94 entries has its properties written down: hardness range, streak color, luster, how it breaks, whether it's magnetic or fizzes, and for fossils, shape and age. The app keeps a probability for every candidate and updates it with each answer. Answers are treated as noisy, because people misjudge luster and vinegar is a weak acid.

To pick the next question, it calculates which one is expected to shrink the uncertainty most (information gain). A few rules keep it sensible. It always opens with a broad "What did you find?", and fossil-only questions wait until the evidence actually leans toward a fossil.

Geology from where you're standing

With your GPS position (GPS works without signal), Streak looks up the bedrock in Macrostrat, an open geologic map database. It turns rock types into odds: a granite map unit boosts quartz, feldspar and mica, and "crinoidal limestone" in the description boosts crinoids directly.

It never rules anything out. Creeks, glaciers and landscaping gravel carry rocks for miles, so local geology only boosts candidates, and there's a "Found it somewhere else?" switch. Fossils also get an age check: outside their time range they're down-weighted, unless you're standing on river gravel, which can hold fossils of any age. Before a trip you can save the geology for about 20 km around you, so it works offline too.

Optional online mode: Llama 4 Scout

With signal, Streak can also send the photo to Llama 4 Scout, Meta's open-weight vision model, running on Cloudflare Workers AI. The request goes through the app's own Cloudflare Worker, so the phone only ever talks to the app's domain. It sends the photo and the name of the bedrock, never your coordinates. The larger model's answer is blended with the on-device one, and if anything fails, it quietly falls back to offline. A toggle on the home screen turns it off.

Fixing what the field test found

The crash: iOS was killing the page because loading the 176 MB fp16 model needed several copies in memory at once. Phones now get the 4-bit model, and there's a crash guard: if the page dies while loading the model, the next launch automatically drops to the lightest setting instead of crashing in a loop.
"That's a rock" about nothing: before identifying, the app now checks whether the photo shows a rock, mineral or fossil at all, by comparing it against descriptions of both specimens and non-specimens (an empty hand, the sky, a room). If not, it says so. Any result under 35% confidence now shows as Unknown with its closest matches, instead of a confident wrong name.
Fossil questions too early: fixed by the question ordering described above.
Rare minerals coming up too often: a rarity prior. Halite dissolves in rain, so it almost never lies on the ground outside deserts, and the app shouldn't jump to it.

Why Does Open Innovation Matter?

For this app, open models weren't just a nicer choice. Several features only work because of them.

It works with no signal. Good rocks are in road cuts, creek beds and canyons, where you usually have no bars. A closed vision API is useless there. Because SigLIP 2 is open, its weights sit on the phone and run in the browser. The geology lookup is open data too, cached ahead of time.

I could host the weights myself, and that saved the project. On the first real test, the model wouldn't download. My network was blocking huggingface.co entirely. With a closed API that would have been the end of it. Because the weights are open, I bundled them into the app and served them from my own Cloudflare site, split into 20 MB pieces the browser stitches back together. Now the app works on any network that can load it.

I could swap models and measure. I benchmarked five open backbones on my own data and switched to the winner for an 11-point gain, without asking anyone's permission or changing any API contracts.

I could train it on my own rocks. Museum and web photos don't look like a phone photo of a dusty pebble in your palm. With open weights I train my own layer on top of the model and keep adding my own field photos. Every crinoid I photograph makes the next ID better.

Your location stays on your phone. Offline mode sends nothing anywhere. Online mode sends a photo and a bedrock name to a model I chose and deployed, not your coordinates to a company whose retention policy I'd have to trust. Where you find good rocks is something collectors like to keep to themselves.

It costs nothing to run. On-device inference is free. Hosting is on Cloudflare's free tier, and online mode fits in Workers AI's free daily allowance, roughly 120 to 160 photo IDs a day.

Everything underneath is open. Open models (SigLIP 2, Llama 4 Scout), open runtimes (Transformers.js, ONNX Runtime), open data (Macrostrat, GBIF, Wikimedia Commons). It's also honest about its limits: it shows you the odds, the closest alternatives, and when it doesn't know.

My Agent Session

I built the app with the help of Claude, where I asked the agent to do the user interface and wiring so I could focus on the logic and the AI under the hood.

Stay on topic with trance

Gavin Rose — Sat, 03 Oct 2026 18:04:59 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

trance is a small Mac app that keeps you focused on what matters most to you in the moment.

To start, just type what you're doing ("answer emails", "study for my upcoming assignment", "do anything except doomscroll"), pick a track, and get on with your day. Every 45 seconds, a Gemma model running locally looks at what you've actually been doing. From there, it decides whether to stay quiet, nudge you back, or tell you it's time for five minutes away from the screen.

I built this for my friend that has mentioned previously having a hard time staying on track. He was looking for something that could help him focus, provide insights, and gently keep him on track.

Most focus apps block the websites or applications you don't want to visit: you list the bad sites and they slam the door. In my opinion, that doesn't fit how people actually drift away from their focused tasks. YouTube is a distraction until it's the lecture you need. Slack is a distraction until you're clearing your inbox. This app doesn't block anything. Instead, it tries to understand what you're doing, compared with what you said you wanted to do.

What it does:

Notices drift. Each window you land on gets labeled against your intent: on-task or off-task, plus what kind of thing it is (work, reference, feed, video, game, etc.). The live view shows the label a few seconds after you switch.
Nudges. When you continue drifting, a small card slides into view, just like a notification. This nudge is intended to bring you back on track without disruption, but also helps the model judge better throughout the session if you tell it that whatever you're doing is actually on-task.
Recommends breaks. Each track has a working period and a recommended break period. If you remain on task, this app will let you continue working. If you start drifting, tab switching, or seem otherwise unfocused, it will suggest taking a break and show a nice calming visual during the break. Breaks are 5 minutes, but you can come back early or add time if you think you need it.
Tracks. Deep Work, Study, Create, Admin Sprint and Cruise each set what on-task looks like, how much switching is normal and how often breaks come. You can also make your own track if you need something a little more customized, along with setting the intent for the session.
Recaps. Whenever you end a session, Gemma writes a short summary of how the session went, any potential time sinks, what you did well, and what you could do better next time.

Screenshots

How I Built It

The open pieces: Gemma 3 4B (instruction-tuned), running locally in Ollama, inside a Tauri app written in Rust.

Gemma reads, then the Rust code decides. Every 45 seconds the model returns a structured opinion of how your focus is going. I used Ollama's format field, which takes a JSON schema, so that the answer always parses properly. Then plain code applies the rules: drift has to show up in two reads in a row before trance says anything, nudges have cooldowns, and flow is never interrupted.

What a 4B model got wrong, and what fixed it

This is the part that required the most time and attention. My first version of the prompt gave Gemma all of the raw activity logs and asked for a verdict. On a 12B Gemma model, this was a pretty good approach. The problem is that a 12B model running constantly while you're doing other work eats a lot of resources, and some people may not have the computer to handle that. When I switched to a 4B model and did a test run, the model decided that me spending 90% of my time on distractions instead of the task at hand was on-task. To combat this, the model now gets the window information and labels it, the Rust code calculates switch rates, scroll rates, typing, on-task time, etc., and the model then gets this structured information rather than being expected to do all of the calculations itself and getting less than ideal results.

Another problem was stale labels. Each window gets labeled the first time you open it, and that label sticks for the session. A browser card game got marked as work and stayed that way, making me look far more on-task than I was. Now the labeler also gets a screenshot of the window, and if a later check-in sees the screen and disagrees with the label, the label is corrected on the spot.

Why Does Open Innovation Matter?

Because of what trance has to look at. To do its job, trance sees every window title you have open, which sites you're on, and how much you're typing and scrolling. With the glance feature on, it sees a capture of your screen about every 45 seconds. With an open model in Ollama, the most private data trance handles never leaves the workstation or laptop. Screenshots are read and deleted, and session logs are plain JSONL files in the user's own directories. No third parties peeking at your usage, no training being done on your data, etc.

Cost and customization. If you're doing a full work day session, you're probably going to leave this running in the background, even while away from the computer. Running locally, each check-in costs nothing but a bit of battery; on a metered API, a full work day in the background adds up fast. Using Ollama also gives you access to a whole plethora of open models, so you can swap them on command to see what works best for your situation.

Where a closed model would have been easier: To be honest, a big hosted model would have needed fewer guardrails and probably would have produced better results more quickly. Most of my weekend went into making a 4B model reliable, but the solutions to those pesky edge cases turned into features that otherwise might not have been considered. The rules that decide whether trance interrupts you are just code that anyone can read: no black box, and no server calls.

My Agent Session

I've always had a weak spot with frontend development and making things look professional, clean, and polished. Because I used Claude Code to create the user interface, I was able to spend my time where I shine best, building the functionality. Claude also helped me track down a few bugs with rendering and permission issues.

Prize Categories

Best Use of Gemma: Gemma 3 4B runs locally through Ollama. It reads user intent, labels windows (with vision), judges focus every 45 seconds, and writes the session recap, all with no cloud calls!

Atlas

Gavin Rose — Sun, 19 Apr 2026 19:25:20 +0000

Explore Earth, One Swipe at a Time

Inspiration

Some of us spend hours every day scrolling. The format is compelling, and the habit is already formed. The question we asked ourselves was what if that scroll actually taught you something?

Atlas takes the interaction pattern everyone already knows and fills it with things worth knowing about the planet we live on... things like geology, ecology, ocean science, extreme weather, wildlife, and geography. No headlines, no opinions. Just Earth facts, beautifully presented.

What It Does

Atlas is a vertical swipe feed of Earth fact cards, built and deployed as a Flutter web app. Beyond the content, Atlas has a full progression system aimed to keep people engaged as they learn about the Earth.

XP and levels: you earn XP for every new card you read, every quiz you reveal, and every card you save. The XP system has eight explorer levels from Seedling to World Wonder, and each level unlocks a new ambient visual theme (Ocean, Forest, Dusk, Aurora, Glacier, Desert, Volcanic).
Achievements: ten unlockable achievements tied to meaningful milestones; exploring five nature cards, saving five cards, revealing five quizzes, exploring all categories, and more.
Daily streak: the app tracks consecutive days of use and surfaces your streak in the HUD once it hits day two.
Dynamic content: the feed mixes 60+ curated cards with live data pulled from four public APIs, refreshed every 24 hours: NASA APOD (astronomy images), USGS Significant Earthquakes (real-time seismic events), Wikipedia article summaries (25 curated Earth topics, four chosen at random per session), and Open Trivia DB (science and geography questions turned into Real or Fake cards).

How We Built It

The entire app is written in Flutter, hosted on Firebase Hosting.

Stack/Packages:

Flutter/Dart
Provider for state management
SharedPreferences for local persistence
http for API calls
flutter_animate for card entry animations and toast transitions
share_plus for native share sheet
Firebase Hosting

Challenges We Ran Into

Swipe-one-card-at-a-time. Flutter's PageView will happily let you queue multiple animateToPage calls, which causes the view to snap to the wrong card when the user swipes quickly. The fix was disabling the PageView's built-in gesture handling entirely and replacing it with a manual drag detector and an animation lock.

Accomplishments We're Proud Of

A scroll experience that feels genuinely close to TikTok or Reels, built entirely in Flutter for web, with no JavaScript.
A progression system that changes the visual environment of the app as you level up, so the reward is aesthetic and immediate, not just a number going up.
Live data from four different public APIs, unified into the same card format as the curated content, with graceful offline fallback.

What We Learned

Short form content, especially as text, forces content to be better. Writing 60+ cards where every headline had to land in under 15 words was harder than any of the actual programming or engineering! XD

We observed that while typically Flutter can be lacking for web development, when developing for designs that are mobile-first, Flutter was still able to shine although it felt like it took a little longer than doing something react-based may have taken.

What's Next

User-generated cards: a simple submission form where anyone can contribute a fact, queued for moderation before it enters the live feed.
More API sources: NOAA for weather extremes, iNaturalist for real-time species observations, NASA Earth imagery.
Personalisation — mood-based filtering (Relax / Curious / Mind-Blown tags are already on every card, just not yet surfaced in the UI).
Native mobile builds: the codebase is already cross-platform; the only web-specific concession is SharedPreferences over localStorage.

Built With

flutter dart firebase nasa-api usgs-api wikipedia-api open-trivia-db provider shared-preferences flutter-animate glassmorphism

Resources

The repo is publicly available here
The build itself can be found here

Scarab | Weekend Data

Gavin Rose — Sat, 18 Apr 2026 12:48:38 +0000

Scarab can give you a summary on what data is missing from your data with only a few clicks
Download Now

The new way to explore data

Gavin Rose — Thu, 16 Apr 2026 17:12:37 +0000

Scarab was built to allow people with no programming or statistical language experience analyze their data. It produces code snippets for those that want to bring insights into their own program, and can help gain valuable insights from your data as you progress. Free while in the testing phase!

debugr.gumroad.com