This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady
What I Built
We've all been there: a Downloads folder full of vaguely named PDFs, screenshots, documents, and files we swear we'll organize someday.
The problem isn't that organizing files is difficult. It's that doing it consistently is tedious.
What if AI could help clean up that mess without turning file management into a black box?
That's the idea behind DustBunny, a local-first AI file organizer built for Hacktoberfest 2026 Week 3.
🐰 What Is DustBunny?
DustBunny helps users make sense of cluttered folders by analyzing files and suggesting more meaningful filenames and folder destinations.
Instead of relying entirely on rigid naming rules, it uses an open-weight language model through Ollama to generate context-aware organization suggestions. It can also explain its recommendations, helping users understand why a file belongs somewhere rather than blindly trusting an automated decision.
The goal isn't to let AI take over your filesystem. It's to make organizing files easier while keeping the user in control.
💡 Why I Built It
File clutter accumulates gradually. A downloaded document gets a generic name, a useful file disappears among dozens of others, and an important resource becomes difficult to find.
Traditional file organizers can help with predictable rules, but meaningful organization often requires understanding what a file is about.
Cloud-based AI introduces another consideration: sending file content to an external service may not be desirable for every user.
I wanted to explore a different approach: make AI-assisted organization practical, explainable, and local-first.
DustBunny brings AI into a familiar workflow while exploring how open-weight models can support useful everyday tasks.
✨ What Can DustBunny Do?
Analyze files: Work with files in a user-selected folder through the application's organization workflow.
Suggest better filenames: Replace generic or unhelpful names with more descriptive alternatives.
Recommend folder destinations: Suggest where files could belong, including meaningful folder structures.
Explain its suggestions: Provide reasoning so users can evaluate the recommendations.
Keep the user in control: Treat AI output as a suggestion rather than an unquestionable instruction.
The central idea is simple: AI should help users make better decisions, not make those decisions invisible.
Demo
Code
DustBunny
A privacy-first, local-only AI file organizer that suggests how to categorize and rename your files — without ever moving, renaming, or deleting them.
The Problem
Folders accumulate: Document1.pdf, notes.txt, scan_20240115.pdf, meeting.md. Finding anything later is a chore. Cloud AI tools can help, but they upload your files to external servers.
The Solution
DustBunny runs entirely on your machine. Point it at a folder (or pick one in the browser), and it:
-
Scans
.txt,.md, and.pdffiles locally - Extracts text (PDF via PyMuPDF, text/markdown directly)
-
Sends only text to a local Ollama model (
qwen3.5:2b) -
Returns structured suggestions per file:
- Category (e.g., "Financial", "Code", "Personal")
- Proposed filename (descriptive, no extension)
- Suggested destination folder
- One-sentence explanation grounded in the content
- Confidence estimate (from the model's own uncertainty)
- Displays results with copy buttons — you decide what to do
No files are ever modified,…
How I Built It
🧠 The AI Behind DustBunny: Qwen 3.5 2B + Ollama
DustBunny uses Qwen 3.5 2B, an open-weight language model served locally through Ollama.
Rather than relying on a hosted LLM API for inference, DustBunny communicates with a locally running Ollama instance. The model generates file-organization suggestions, including meaningful filenames and suitable folder destinations.
Choosing a compact model was an important engineering decision. I wanted to explore how local AI could handle a practical task on everyday hardware without depending on a paid inference API.
During development, I initially experimented with Gemma 3 1B before switching to Qwen 3.5 2B. I then refined the inference configuration, including disabling extended thinking, to reduce unnecessary latency and help the model produce the structured output the application expects.
Working with a smaller local model also introduced practical challenges. Model outputs are not always perfectly structured or consistent, so the application needs validation and error handling rather than blindly trusting every response.
That experience shaped an important design principle: a useful AI application needs more than a capable model; it needs a reliable system around it.
By combining Qwen 3.5 2B with Ollama, DustBunny explores a practical alternative to cloud-dependent AI workflows. Local inference supports the project's privacy-conscious design, although the application's overall network behavior still depends on its configuration and other services.
🛠️ How It Works
DustBunny combines a modern web interface with a Python backend and a locally run AI model.
Frontend — React + Vite
Provides the interface for interacting with the file-organization workflow and reviewing suggestions.
Backend — Python + FastAPI
Handles the application's backend logic and communication between the interface and AI-powered functionality.
AI — Qwen 3.5 2B + Ollama
Runs the language model locally to generate context-aware suggestions for filenames and folder destinations.
The application is designed around a local-first workflow. Rather than treating AI output as an instruction to execute blindly, DustBunny focuses on producing suggestions that users can review.
Why Does Open Innovation Matter?
🔓 Why Open-Weight AI Matters
Open-source software is most useful when people can inspect it, learn from it, adapt it, and build on it.
DustBunny explores the practical side of open-weight AI: using a model as part of a real application rather than stopping at a chatbot or a standalone model demonstration.
Running a compact model locally also creates opportunities to experiment without depending on a hosted inference API, subject to the user's hardware and configuration.
It highlights an important design principle for AI-powered tools: recommendations should be understandable, and people should retain control over consequential actions.
There is room to improve file classification, recommendation quality, evaluation, and support for different local models. An open-source foundation makes those improvements possible through community feedback and contributions.
🧰 Built With
React + Vite — Frontend
Python + FastAPI — Backend
Qwen 3.5 2B — Open-weight language model
Ollama — Local model inference
Top comments (0)