Put the Phone Down. The Sky Has Something to Show You.

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

What I Built

On a clear night away from cities, the sky is full of stars, and I could name almost none of them. Every stargazing app I tried had the same problem: to see the sky, you stare at a bright screen held up against the sky.

Look Up is an offline night-sky field guide built around one idea: phone down, look up.

• Tonight list. What's worth seeing right now from where you stand, with direction, height and best time, in plain words ("low in the east"), not raw degrees.
• Quests. Each target starts as a puzzle ("three bright stars in a big triangle"). Hints only come if you ask.
• Point & check. Hold the phone up and the compass and tilt sensors tell you if you're getting warmer. No camera.
• A local AI guide. A small open-weight language model runs inside the browser, offline, and answers questions about the target.
• Found screen. When you find something, the app gives you a fact and a 30-second countdown that asks you to put the phone away and just look.

There are 11 beginner targets: the Pole Star, the Summer Triangle, Cassiopeia, the Big Dipper, the Great Square of Pegasus, the Pleiades, Orion's Belt, Sirius, Antares, tonight's planet and the Moon. Levels are meant to remove help step by step. The real goal is that you stop needing the app.

It's for people like me: beginners who have never found anything in the sky except the Moon.

Demo

Try it: https://lookupsky.netlify.app/

It's built to work offline: open the site on Wi-Fi, ask the guide one question so the model downloads (about 470 MB, stored in your browser), then install it from the browser menu. Works best in Chrome on Android.

Here's a quest from start to finish:

1. The Tonight list: what's up right now, which direction to face, and when it's best to look.

2. A quest starts as a puzzle. No answers, just "find three bright stars that form a big triangle."

3. Stuck? Hints come one at a time, and only if you ask.

4. Point & check: hold the phone up, and when you're aimed right, it tells you to lower the phone and find it with your own eyes.

Code

meawdak / Look-Up

Look Up

Look Up: an offline night-sky field guide. Phone down, look up.
Built for the DEV Touch Grass challenge (Hacktoberfest 2026).
Try it: https://lookupsky.netlify.app/

What it does

• Tells you what is worth seeing tonight from where you stand, with direction, height, and best time.
• Offers puzzle-style quests for night-sky targets, with hints revealed on request.
• Provides Point & check guidance using compass and tilt sensors without using the camera.
• Includes a small open-weight AI guide that runs locally in your browser, completely offline.
• Works offline as an installable progressive web app (PWA).

Why open-source and open-weight

• Works with no signal under dark skies away from cell towers.
• Location data stays on your device and is never sent to a server.
• Runs without API keys, accounts, or ongoing running costs.
• The model is swappable with any small GGUF model supported by wllama.

How the AI is kept honest

The sky…

View on GitHub

How I Built It

Stack: plain JavaScript and Vite, built as an installable offline web app (PWA). Positions of the Sun, Moon and planets come from astronomy-engine. Stars come from the HYG database, filtered to the 1,637 stars bright enough to matter. The AI is Qwen2.5-0.5B-Instruct (Q4_K_M quantised, about 470 MB), running in the browser through wllama, which is llama.cpp compiled to WebAssembly.

My laptop is an i3 with 4 GB of RAM, so "small" was not optional.

The one rule I built everything around: the sky engine decides what is true; the language model only decides how to say it. The model never calculates a position and never supplies a fact.

Here's how a question flows:

1. Code works out the facts for this target, tonight, from where you are.
2. A quick answer built by code appears instantly, so the screen never feels frozen.
3. The model gets a few short facts, written as words, and rephrases them.
4. A guard checks every name and number in the model's answer against the sky data. If anything doesn't match, the answer is thrown away and the quick answer stays.

The suggestion buttons ("How far away is it?") don't use the model at all. Code answers them directly. The AI is only used for questions you type.

What a 0.5B model taught me:

• It can't read numbers. In astronomy, a lower magnitude means brighter. On my phone, the model looked at the raw numbers and told me Deneb was the brightest star in the Summer Triangle. It's not; Vega is. The fix was to let code do every comparison and give the model words ("the brightest of the three") instead of numbers.
• Big prompts make small models copy. My first version sent a large block of data. The answers took 108 and 85 seconds on my laptop and mostly repeated my own hint text back to me. Sending fewer facts that are specific to the question made answers both better and faster.
• The guard works. I asked "Who discovered it?" about a star. That fact isn't in my data, the model made up an answer anyway, and the guard rejected it. That was the moment the whole design made sense to me.

Speed, honestly:

Device	Version	Time
Laptop (i3, 4 GB)	First version	108 s and 85 s
Laptop	Smaller facts + guard	54.6 s (model load 4.3 s)
Laptop	Multithreading on	17.1 s (automated test run)
Phone (Android, 8 GB)	Early version, incl. load	47.9 s

That's still slow, which is why the code answers come first and the AI is an optional extra.

I built this with an AI coding agent (Google Antigravity) writing most of the code from my prompts. One lesson: it often said things worked without actually running the model, so I tested everything on my own laptop and phone.

What I deliberately didn't build: camera star recognition (phone cameras catch few stars, and the real technique is plate solving, not a language model), an AR sky map, accounts, cloud sync and weather. A sky darkness check is planned but not built. Levels 2 and 3 are only partly implemented.

I Took It Outside

I took Look Up outside for about 15 minutes, standing beside a main road with some bushes on one side. It did not go the way the app imagined.

The sky was barely there. I could see two to four stars with my naked eye, all of them fairly high overhead. Near the horizon there was nothing. The whole sky had a glow from streetlights, and there was heavy haze, probably smoke and pollution as well.

Northwest: one bright star, clearly visible. Everything else in that direction was too faint to make out.

East: Look Up told me Saturn was in the east, low in the sky. I looked for a while and couldn't find it. Low objects shine through the thickest part of the haze, and that side of the sky was the brightest from city lights.

What I learned: the app was right that Saturn was above the horizon, but being above the horizon is not the same as being visible. My sky engine knows where things are. It has no idea what the air and the lights around you are doing to them.

That is exactly the gap the planned sky darkness check is meant to fill: count the stars you can actually see, and let the app adjust what it suggests, or nudge you toward a darker spot. After that night, it moved from "nice idea" to the first thing I want to build next.

It wasn't the magical stargazing session I pictured. But for fifteen minutes I wasn't looking at a screen. I was squinting at a hazy sky, trying to find a planet. That's the whole point of the app, even when the sky doesn't cooperate.

Why Does Open Innovation Matter?

For this app, it's not a nice extra. Without open weights the app doesn't work.

• Dark skies have no signal. The best places to stargaze are far from cities, which usually means far from mobile networks. A guide that calls a cloud API fails exactly where it's needed. An open-weight model runs on the phone itself.
• Your location stays on your phone. The app needs to know where you're standing. Nothing is sent anywhere, because there's nowhere to send it.
• No API key, no bill. It costs nothing to run, for me or for anyone who forks it. A student project can stay online without a credit card.
• The model is swappable. Any small GGUF model can replace Qwen. When better small models come out, the app gets better without me changing the design.

Open data mattered just as much: the star catalogue, the constellation lines and the astronomy maths are all openly licensed. I wrote the glue. The sky came from other people who chose to share.

Thanks for reading. Now go outside and look up.