DEV Community

Cover image for I got tired of checking my Mac, so I built a little 👻Halloween light to do it for me (Arduino UNO Q + Gemma)
Priyanshu Patel
Priyanshu Patel

Posted on Edited on

I got tired of checking my Mac, so I built a little 👻Halloween light to do it for me (Arduino UNO Q + Gemma)

Hacktoberfest Open-Source AI Challenge: Ghost in the Machine Submission 👻🌼

This is the project which was made for week three, but what happened I submitted before time, but still when I edited few things in it after the deadline, it gets submitted for the week four, so now change it the whole idea with the theme of week four. You might also find the same two post as I am getting some errors that it is not submitted, so I had submitted it twice.

I got my Arduino UNO Q at a Hacktoberfest meetup, and now I'm finally putting it to use! I'm building Still Loading... as my project for Dev Challenge, giving the board a little Halloween Theme.

My terminal has ghosts, so I built a little Halloween device to catch them (Arduino UNO Q + Gemma)

I kept staring at a terminal for jobs that had already died.

A job can look alive and still be gone. A download can crawl while I keep refreshing its percentage. A traceback can sit unnoticed in another terminal. Sometimes, it feels like my computer has a few ghosts of its own.

So I built Still Loading...: an Arduino UNO Q whose 8×13 LED matrix shows what my Mac is doing, so I can glance at my desk instead of constantly checking the screen. When a job fails, a local Gemma model explains why, and my code checks that the log line it quotes really exists.

For Week Four, I gave the project a Halloween transformation. The underlying idea is the same, but its visual identity is now inspired by ghosts, skulls and other spooky illustrations. What started as a small status light now looks like a little haunted companion for my desk.

Why I built this

I got my Arduino UNO Q at a Hacktoberfest meetup. It was my first Arduino, and I had never built anything on one before. When this challenge came up, I wanted to use it for a real project instead of leaving it in a drawer.

My first idea list was the obvious one: a plant-watering device, an email or message summarizer, and similar ideas. I looked around and saw that people had already built these, and built them well. I didn't want to make a copy of something that already existed just to have an Arduino in the photo.

So I asked a different question: what do I keep doing by hand that a small light could do for me? The answer was already on my screen. I kept checking terminals and download bars to see whether something was still alive.

That is where the idea of ghost jobs came from: processes that look alive but have already stopped making progress or have failed without me noticing.

I wanted a light that stays quiet while things are fine and gets my attention when something needs me. That is the problem Still Loading... tries to solve.

From status light to haunted desk companion

The Halloween theme gave me a reason to rethink the illustrations throughout the project.

Instead of relying on ordinary status symbols, I refreshed the visuals with spooky, horror-inspired artwork. The idea was to make the matrix feel like a small Halloween device rather than a conventional system monitor.

The ghostly visual direction fits the project naturally:

  • Ghosts represent jobs that have disappeared or become unresponsive.
  • Skulls and darker illustrations give failures a more recognisable visual identity.
  • Pumpkins, bats and other Halloween-inspired artwork bring personality to the ordinary status displays.
  • The overall look makes the device feel like a little haunted companion sitting beside my computer.

This is a visual transformation of the existing project. The underlying monitoring, communication and diagnosis flow remains the same.

TL;DR

  • A little ghost watcher for my desk. The matrix shows idle, running, completed, failed, suspected stall, battery, charging and download.
  • Halloween makeover. The illustrations have been refreshed with a spooky visual identity.
  • Real data, not animations. It showed a live Chrome download climbing from 0% to 15%, and real macOS battery readings.
  • Gemma explains, code verifies. gemma2:2b runs locally on my Mac and quotes a log line. Plain code checks the quote is in the redacted log and marks the answer VERIFIED or UNVERIFIED. One live call took about 4.6 seconds.
  • Tested. 20 captured failure logs as a baseline. The latest full run passed 202 Mac-agent tests, 2 relay tests, the web tests, the demo suite and the production build.
  • Honest boundary. Gemma runs on the Mac. The UNO Q receives state and displays it. VERIFIED means the quote exists, not that the diagnosis is right.


Updated visuals for the Halloween

How it works

The computer does the work. The board makes the state visible.

Browser Control Deck → Mac backend (battery, Chrome downloads, jobs, Gemma)
      → UNO Q HTTP receiver → App Lab bridge → 8×13 LED matrix
Enter fullscreen mode Exit fullscreen mode
Layer What it does
Mac Battery reader (pmset), Chrome download monitor, job runner, log redaction, Gemma, evidence check, Control Deck backend
UNO Q Linux HTTP receiver and App Lab bridge
LED matrix Draws each state as a pattern

The Control Deck is a browser page with six buttons: Battery, Download, Run Job, Failed, Reset and Stop. Each calls a fixed backend operation. The browser never runs arbitrary shell commands. The same state drives a matrix preview on the page and the physical matrix.

The Halloween illustrations change how the information looks, not what the underlying states mean.

Gemma explains, code verifies

A small model can invent a log line that sounds right, so it has to prove its answer.

Failure log → redaction → local Gemma → diagnosis + quoted line → exact-match check → VERIFIED / UNVERIFIED
Enter fullscreen mode Exit fullscreen mode

I ran python3 run_job.py --gemma -- python3 -c "import non_existent_pkg_xyz". The log ended in ModuleNotFoundError: No module named 'non_existent_pkg_xyz'. Gemma called it a missing dependency, severity error, and quoted that line. The checker found it in the log and returned verified.

If Gemma times out or returns malformed output, a rules-based explainer takes over. The failure state never waits for the AI.

Evidence

I tested Still Loading... against captured failure logs and real system activity, rather than relying only on simulated progress or an AI answer that sounds convincing.

Measure Result
Failure logs captured 20 examples covering Python, Node.js, Git, a non-executable script and refused connections. Two empty excerpts were excluded from text-based analysis.
Gemma diagnosis In a live test, a deliberately triggered ModuleNotFoundError was classified as missing_dependency, with severity error and confidence around 0.9.
Evidence verification In that example, Gemma quoted the missing-module error and the checker found the quoted text in the redacted log, returning VERIFIED. Tests also cover genuine and fabricated quotes.
Gemma response time One observed live call took approximately 4.6 seconds. The configured timeout is 8 seconds, with a rules-based fallback for timeouts or invalid responses.
Chrome download progress Real progress updates were observed from 0% to 15%, including intermediate percentage changes.
Download test coverage Automated tests cover progress values including 0%, 1%, 50%, 86%, 99% and 100%, unknown totals, zero-byte cases, completion, failure, cancellation and duplicate-update handling.
macOS battery Real readings of 100% and 99% were observed.
Automated software tests The latest reported run passed 202 Mac-agent tests and 2 relay tests, along with the web tests, demo suite and production build.

What these results prove

The live failure example demonstrates that Gemma can explain a deliberately triggered failure and that the evidence checker can verify its quoted text against the redacted log. The captured logs and automated tests provide a starting point for evaluating more cases.

These results are not an overall accuracy benchmark. I have not established aggregate figures for diagnosis agreement, quote-verification rate or Gemma timeout frequency across the 20-log fixture. I also have not established measured watchdog catch rates for genuine stalls or false alarms on slow-but-healthy jobs, so I am not claiming those numbers.

One hardware distinction matters: the receiver returned 200 OK to an authenticated request, confirming network reachability. The full Control Deck-to-physical-matrix path was subsequently recorded on the board on 26 October.

These are early engineering results, not a benchmark. They document what I have tested and leave the unmeasured results clearly identified as work still to do.

What went wrong on the hardware

  • Wrong address. SSH to 192.168.1.5 was refused. The board was at 192.168.1.10.
  • Wrong Python. Running the App Lab script with system Python gave No module named 'arduino'. It needs the App Lab runtime.
  • Missing token. The receiver refused to start until its bearer token was set. After that it listened on port 8090 and answered 200 OK on /v1/lights.

The lesson: when the web preview changes but the board does not, trace the state link by link instead of rewriting the renderer.

Why open matters

Failure logs hold tokens, private paths and URLs. I redact known secret patterns, cap what Gemma sees at about 6,000 characters, and keep inference on my Mac, so the raw log never goes to someone else's server. Open parts also let me inspect why the matrix changed and exactly what the model was shown. A hosted model might diagnose hard failures better and faster. For a one-sentence explanation checked by code, local was enough.

Limits

  • Gemma runs on the Mac, not on the UNO Q.
  • VERIFIED proves the quote exists, not that the diagnosis is correct.
  • Redaction is pattern-based and can miss unusual secrets.
  • Battery readings are whole-number percentages. If the Mac sleeps, monitoring pauses and the board keeps its last state.
  • 20 logs is a small baseline, not an accuracy study.

The lazy payoff

I wanted a device that would let me stop checking whether every process was still alive.

Now, instead of constantly watching terminals and download bars, I can glance at a little Halloween-themed display on my desk. When everything is fine, it quietly shows the status. When a job fails or becomes unresponsive, the ghostly visuals make the change harder to miss.

A ghost is the job I used to keep checking. Now the light does it.

AI use

I used AI assistance to build this. Gemma is also a runtime part of the project, running locally. It never controls the hardware, and the light does not depend on it.

Want to try Still Loading...?

You can check out the live version here: Live Demo.

Still Loading — Haunted Hero

💀 STILL LOADING...

"Your Mac has activity. Your desk has ghosts."

An Arduino UNO Q device that watches your Mac in the dark —
Chrome downloads, battery, charging state and job health, rendered as horror pixel art
on an 8×13 LED matrix. When things go wrong, the ghosts come out.


Python Arduino React Tests License Status


🌐 Live Demo · 💀 GitHub Repo · 🎃 Quick Start


——— ✦ ———

🕯️ The Idea — What Haunts This Machine?

Your Mac is always doing something. Files downloading in Chrome. Battery silently draining. Background jobs creeping along. Terminal processes failing in the dark.

Still Loading... is a physical bedside gadget — an Arduino UNO Q — that keeps watch so you don't have to. Its 8×13 LED matrix shows you exactly what your Mac is doing right now, displayed as atmospheric Halloween-themed pixel art that fits right into the horror aesthetic of a late-night dev session.

No app to open…

Want to run it on your own Mac? Head over to the GitHub repository, where the README includes the setup instructions and steps to get the project running on your computer. Give it a try! 👻

Repo: https://github.com/priyanshuspatel/Still_Loading...

· License: MIT Licence ·

Demo video: https://youtu.be/WynEIrjoguQ ·

Updated with Halloween version: https://youtu.be/ZAkOoChQL1U

Author: Priyanshu Patel

Prize categories

Best Use of Arduino. The UNO Q is the physical end of the system: it receives state and shows progress, completion, failure, battery, charging, download and suspected stall on its 8×13 LED matrix. The Halloween illustrations give that physical feedback a distinctive visual identity. The model currently runs on my Mac, not on the UNO Q, so my entry focuses on the physical-agent side of the category: using the board to turn real system activity into a visible, glanceable signal.

Best Use of Gemma. Gemma explains redacted failure logs with severity and a recommended action, and its quoted evidence is checked in code.

Top comments (0)