I Won an Arduino UNO Q at a Hack Day. Now I'm Building a Device to Help Me Touch Grass

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

What I Built

Honestly, I didn't plan to work on hardware this week. 😅

A little while ago, I attended an offline hack day in my city. I went there as an individual participant without a team. But I got to meet three other people, we connected, and we decided to build something together.

We named our team Wasted Token.

We had around six hours to build a project. We decided to work on a tool that helps developers avoid accidentally pushing secrets into their Git commit history. The idea was to detect things like API keys, passwords, and access tokens before they become part of a commit.

We spent those six hours building, debugging, and trying to get everything working. And luckily, we won the hack day.

Along with some awesome swag, one of the prizes was an Arduino UNO Q.

That was the beginning of a completely new adventure for me.

I'd heard about Arduino before, but I had no real experience with electronics or hardware development. Most of my experience was with software, web applications, and developer tools.

So naturally, I got curious about what this board could do.

I started reading the documentation, exploring the examples, and trying things out on the device. The more I explored, the more I realized how much there was to experiment with.

The UNO Q combines a Linux-capable processor for running applications and AI with a microcontroller for interacting with hardware. It even has a built-in LED matrix!

Then I came across the Hacktoberfest Open-Source AI Challenge: Week 1 — Touch Grass.

The challenge was about building something with open-source AI that encourages people to spend less time on screens and more time in the real world.

I started thinking: What if I used this device to build something that helps me take better breaks from my own devices?

And that's how Outmark started.

Meet Outmark

Outmark is a screen-free break companion built around a simple idea: make a promise to yourself, step away from your screen, and keep a record of the activities you complete.

We all know how this goes. You sit down to study or code, spend hours staring at a screen, and eventually decide to take a break. Somehow, that break turns into scrolling through social media or watching random videos.

I wanted to experiment with a different approach.

Outmark helps you make small commitments to spend time away from your screen. It might be taking a short walk, sitting outside, observing your surroundings, or simply taking a few minutes away from your desk.

Here's how it works.

1. Choose an activity

Outmark uses a locally running open-weight AI model to suggest a practical outdoor or screen-free activity. You can accept the suggestion or reject it and request another one.

2. Make a promise

Once you accept an activity, the timer starts. If you choose five minutes, you cannot mark the commitment as kept before the full five minutes have elapsed.

You don't need to keep staring at the webpage. The session continues even after you close it.

3. Report what happened

When the timer ends, you can report whether you kept your promise or didn't manage to complete it. You can also record a short reflection about your experience.

Outmark doesn't pretend to know what you did while you were away. Without additional sensors, it cannot verify whether you actually went outside. The point is personal accountability, not surveillance.

4. See your offline activity on the device

This is where the Arduino UNO Q becomes an important part of the project.

The board's built-in LED matrix displays a visual record of your recent activities. Instead of using the display just for decoration, I'm using it as a tiny activity monitor.

The goal is to make your screen-free habits visible without needing to open another dashboard every time.

Why the Arduino UNO Q?

This is probably my favorite part of the project.

I could have built Outmark as a normal web application, but then I wouldn't really be exploring what makes the UNO Q interesting.

I wanted the hardware to play a meaningful role in the product.

The Linux side handles the intelligence.

It runs the local AI model, generates activities, manages commitments and timers, and stores activity history. The core application is designed to work without relying on a cloud AI service once everything has been installed.

The microcontroller handles the physical experience.

The STM32 side manages the LED matrix and its animations. The display responds to different moments in the user's workflow.

When a commitment is accepted, the matrix can show a confirmation animation. While the timer is running, it can show progress. When the timer expires, it can display a different pattern. After the user reports the outcome, the activity monitor updates to reflect the recorded activity.

The display can also show a rolling 13-day activity chart.

The matrix is only 8 × 13 pixels, which means it has just 104 blue LEDs. It isn't suitable for detailed illustrations or paragraphs of text.

Instead of fighting that limitation, I'm trying to make the small display useful through simple pixel patterns, visual states, and purposeful animations.

I think that's one of the most interesting parts of building for this hardware: figuring out how to create a useful experience within its physical limitations.

How the Activity Monitor Works

The activity monitor is designed to show eight categories of screen-free activities across thirteen days.

For example, the categories can include:

• Walking and movement
• Nature observation
• Quiet outdoor time
• Social connection
• Outdoor care or helping
• Exploring a new place
• Creative observation
• Other offline activities

Each row represents an activity category, and each column represents a day.

When a user reports keeping a commitment, Outmark records the activity in the appropriate category and updates the visual chart.

The webpage shows the category names, dates, and more detailed information. The physical matrix displays the pattern itself.

This makes the display useful without trying to squeeze too much information into 104 pixels.

The activity history is based on what the user reports. Outmark doesn't claim to automatically track or verify physical activity.

How I'm Building It

I'm approaching the project with a relatively simple architecture.

For the application and session management, I'm using Python with a lightweight local web interface. The application handles commitments, validates timer completion, stores reports, and updates the activity history.

For the hardware, I'm using Arduino sketches to control the LED matrix and communicate with the Linux application through Arduino Bridge.

For AI, I'm exploring a compact open-weight language model that can run locally on the UNO Q's 4 GB RAM variant. My current candidate is Qwen2.5-0.5B-Instruct in a quantized format, using a compatible local inference runtime.

The AI has a focused job: generate practical activities based on the user's available time and preferences, then use recent activity history to avoid suggesting the same things repeatedly.

I don't need a huge model or a complicated agent framework for this. I'd rather use a small model for one useful task than add a chatbot that doesn't contribute much to the experience.

The timer and completion rules are handled by normal application logic. The AI doesn't decide whether a commitment has been completed or directly control the hardware.

I'm also keeping activity history and reflections local. Once the model and dependencies are installed, the core experience should work without cloud AI APIs.

Since this is my first serious experiment with the UNO Q, I'm learning as I build. I've been exploring the documentation, running examples, and figuring out how the Linux application and microcontroller can work together.

It's been a fun change from my usual workflow!

Why Does Open Innovation Matter?

For me, open-source AI isn't just about using a model with an interesting name.

It's about having control over the experience.

I want Outmark to work without sending every activity request or personal reflection to an external AI service. Local inference lets the model run on hardware I control, and the activity history can stay on the device.

Using an open-weight model also means I'm not locked into one proprietary API. I can experiment with other models, inspect their licenses, change the prompts, and replace the inference runtime when it makes sense.

There is also a practical benefit: no mandatory per-request AI bill.

Of course, local models have limitations. A small model won't necessarily perform as well as a much larger hosted model, and it still needs enough memory and processing power to run comfortably. That's why I'm keeping the AI task narrow and using deterministic application logic for things like timers and activity records.

The hardware side follows the same philosophy. I can explore the code, change the matrix animations, and experiment with how the Linux and microcontroller sides communicate.

For me, this challenge is an opportunity to explore how open AI can be useful beyond chatbots and developer tools. It can also be part of a small, physical device that encourages people to spend less time using their devices.

What I'm Learning Along the Way

The biggest part of this project has been stepping outside my usual comfort zone.

I went to an offline hack day, met three people, formed a team, and built a developer security tool in six hours. Winning the event and getting the UNO Q gave me a reason to explore a completely new area.

Now I'm learning about embedded development, local AI inference, the communication between two computing environments, and how to design an interface for a display with only 104 pixels.

I'm also thinking more carefully about the product itself. The challenge isn't simply to make an LED matrix light up. It's to make sure the hardware has a real purpose, the timer behaves correctly, the activity history is accurate, and the AI contributes something useful.

I'm still exploring, but that's what makes this project exciting.

Demo

Code

utsavdotdev / outmark

An open-source, local-AI-powered break companion that encourages screen-free activities and visualizes your offline habits on the Arduino UNO Q's LED matrix.

Outmark

Outmark is a self-accountability companion for the Arduino UNO Q. You choose a few minutes and a kind of time outside, get one activity from a model running on the board, step away, and later say whether you kept the promise. A kept report lights one cell on the 8×13 LED matrix.

The mark is your report. Outmark does not track your location, take a photo, or decide for you. The timer ending does not count as kept. You do.

How it works

The page is the whole interaction.

1. Pick 5, 10, or 15 minutes and one of eight categories.
2. Suggest an activity. The on-board model writes one. Another suggestion throws it out and asks again. Nothing is timed until you accept.
3. Accept and start. The ring counts down from the board, so closing the browser does not stop it.
4. When the time is up, the page asks how…

View on GitHub

Prize Category

Best use of Arduino

Final Thoughts

I started this journey because I won a development board at a hack day. I kept exploring because I wanted to understand what it could do. And now I'm using it to experiment with a problem I experience myself.

That's what I enjoy about hackathons: you sometimes go in to build one thing and come out with an entirely new direction to explore.

Outmark is a learning experience for me, especially on the hardware side. But I hope it becomes a useful little companion for people who want to take better breaks and spend more time away from their screens.

Sometimes the best thing technology can do is help us put it away for a while.

Thanks for reading!