Miso: A Fully Offline Local AI Desktop Pet That Nags You to Go Outside

An AI Desktop Pet That Will Scold You

During the first week of Hacktoberfest's "Touch Grass Challenge," developer CodewithTanzeel submitted an intriguing project — Miso. It's an interactive desktop pet (Pikachu-style) that lives in the corner of your screen, but its real selling point isn't cuteness. It's the fully local, zero-cloud-dependency AI architecture running underneath.

Miso tracks your focus time, and once the timer hits zero, it gets "angry" — generating a unique scolding line via a locally running LLM, then reading it aloud using offline TTS to nudge you to step away from your desk and go outside to "touch grass." No data ever leaves your machine.

What makes this project especially noteworthy is its deliberate design for old, low-spec hardware — specifically targeting an i7-6600U with 8GB RAM. In an AI app ecosystem that increasingly demands high-end GPUs or paid APIs, this is a refreshingly contrarian approach.

What It Actually Does

Miso embeds a small local model (SmolLM2 or Qwen2.5) into a desktop widget to deliver several interactive features:

Hover interaction: Dances and displays emotions when you hover over it
Drag to reposition: Can be placed anywhere on screen
Idle tracking: If you actually walk away, it "calms down"
Universal customization: Switch characters via the MISO_CHARACTER=my_pet environment variable
Character center: Drop in a GIF and a config.json to create your own pet

In other words, it's not just a fixed-skin desktop mascot — it's an extensible framework. Developers can swap out character assets or even the "brain" powering it. Any compatible .gguf model can be plugged in.

SmolLM2 is a series of ultra-compact language models released by HuggingFace in 2024, available in three sizes — 135M, 360M, and 1.7B — designed specifically for edge devices and on-device inference. Despite its small size, its carefully curated training data (primarily high-quality code and synthetic instruction datasets) enables even the smallest variant to handle basic text generation and instruction-following tasks. Qwen2.5 is Alibaba's 2024 update to the Tongyi Qianwen series, offering sizes ranging from 0.5B to 72B. The 0.5B and 1.5B variants are popular for local deployment thanks to their relatively strong bilingual (Chinese/English) capabilities. Both model families are available in quantized .gguf format, loadable directly via the llama.cpp ecosystem.

Tech Stack: Lightweight by Design

Every technology choice in Miso centers around one goal — running on underpowered hardware:

Python 3.10+ with PyQt6 (requires Qt6 runtime) for the UI
transformers plus llama-cpp-python for CPU-based inference of open-source .gguf models
pyttsx3 for offline text-to-speech
pynput for idle detection

The most critical decision here is the CPU inference path via llama-cpp-python. It trades away GPU-accelerated performance in exchange for the ability to run small-parameter models on laptops with no discrete GPU and limited RAM. Compact models like SmolLM2 were themselves designed for edge deployment, making them a natural fit for this philosophy.

.gguf is a model serialization format defined by the llama.cpp project — short for GPT-Generated Unified Format. It bundles model weights, hyperparameters, and tokenizer information into a single file that can be loaded and run without a Python deep learning framework like PyTorch. Compared to native HuggingFace weight formats, .gguf files are typically quantized — for example, at 4-bit or 8-bit precision — which can compress a 1.7B parameter model from several gigabytes down to a few hundred megabytes, with a corresponding drop in memory usage. This is precisely what makes it viable on an aging laptop with 8GB of RAM. llama-cpp-python is the Python binding layer for llama.cpp, letting developers invoke the highly efficient C++ inference engine with just a few lines of Python — no CUDA drivers or discrete GPU required.

What Shipped This Week

As a Hacktoberfest project, this week's PRs focused on engineering polish rather than feature additions:

Fixing deprecated parameters
Fixing the model download script
Configuring memory-efficient local AI execution
Adding a local memory file (recording state locally and securely)
Cleaning up .gitignore, improving documentation and tests, adding a TTS fallback, and fixing installation errors
Writing a user guide that emphasizes the local, private, and memory-efficient nature of the project
Documenting Qt6 / MSVC runtime requirements with Linux/Mac alternatives

These changes may seem minor, but they're often the deciding factor in whether anyone else can actually get an open-source project running. The quality of installation scripts, dependency documentation, and cross-platform instructions often determines a tool's longevity more than flashy features ever could.

Why Open Source AI Is Non-Negotiable Here

The developer explicitly argues in the project why a cloud-based solution won't work. If this were built on cloud APIs, the challenge itself would fail — it would require internet access, send your screen usage data to a server, cost money per API call, and simply couldn't run on aging hardware in the first place.

Miso is trying to prove the opposite: that you can have a powerful, private, auditable, fully offline AI companion — and swap out its "brain" for any compatible .gguf model at any time. This touches on several core values of on-device AI: privacy (data never leaves the device), cost (zero subscriptions), control (both code and model are auditable), and lower hardware barriers.

For users concerned about personal data being uploaded, or those who only have an old laptop on hand, projects like this offer a viable alternative path.

"Auditable" here means more than just viewing source code — it includes transparency about the model itself. Using a local .gguf model means users can know exactly which version and quantization level they're running, rather than depending on a black-box service behind a remote API that can be updated or shut down at any time. This matters especially in privacy-sensitive scenarios. Miso needs to monitor keyboard and mouse activity (via pynput) to determine whether the user is idle — behavioral data that would raise serious privacy concerns if processed via the cloud. The fully local architecture allows this feature to work while keeping the user in complete control of their data.

Quick Start

The project provides a standard local deployment flow:

git clone https://github.com/CodewithTanzeel/touch-grasschallenge-miso.git
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt
python scripts/download_models.py
python main.py

Windows users can simply run .\install.bat. There's no API key configuration or account registration — consistent with the project's "zero cloud, zero subscription" positioning.

A Few Takeaways

Miso is a lightweight, playful project — but the direction it points toward is worth paying attention to. As small open-source models like SmolLM2 and the compact variants of Qwen2.5 continue to mature, "running an LLM locally on an ordinary or even aging PC" is graduating from technical demo to practical tool. Wrapping these models in a moody, interactive desktop companion is a clever way to lower the perceived barrier for everyday users.

That said, its ceiling is constrained by CPU inference and the models themselves — output quality and response speed can't match cloud-hosted large models. But for something as lightweight as "nagging you to go outside," that's actually a reasonable trade-off between capability and privacy.