LazyDesk AI: Let Your Local AI Handle the Digital Mess 🦥💜
This is a submission for the Hacktoberfest Open-Source AI Challenge — Week 3: Slow and Steady.
What I Built
Have you ever downloaded a PDF, saved a screenshot, renamed a document three times, and then completely forgotten where you put it?
Same problem, too many files, and somehow the job of organizing them always gets postponed.
That's why I built LazyDesk AI — a local-first, AI-powered file organizer designed to make digital clutter less overwhelming.
Instead of relying entirely on manually organizing files, LazyDesk AI explores how a local language model can help suggest clearer filenames and useful categories based on file metadata.
The goal is simple: spend less time deciding where files belong and more time doing the work that actually matters.
✨ What LazyDesk AI brings to the table:
- 🗂️ A focused workspace: A dashboard with Overview, File Organizer, Activity, and Settings pages.
- 🧠 AI-powered suggestions: Gemma 3 running through Ollama can analyze file metadata and generate structured suggestions.
- 🔌 Local AI status: Check whether the backend can connect to Ollama and whether the model is available.
- 🎨 A clean interface: A dark, violet-accented UI designed to make organizing feel less like another chore.
- 🔐 A local-first approach: AI inference runs through Ollama on your own machine rather than requiring a hosted AI API.
The project is still evolving. The dashboard currently includes sample workspace data, and I am working toward a complete folder-selection and organization workflow. I want to be transparent about that: this is a working prototype, not yet a fully automated file manager.
Demo
GitHub repository: Shikha18Shukla/LazyDesk-AI
The repository contains the source code and setup instructions to run the project locally.
The application currently runs locally, so I don't have a public hosted demo to share yet. The next milestone is to connect the folder-selection flow end to end and demonstrate the complete experience with real files.
Code
Explore the project here:
The project is organized into two main parts:
- Frontend: React, TypeScript, and Vite.
- Backend: Python and FastAPI, with an endpoint for analyzing file metadata.
The backend communicates with Ollama locally and uses gemma3:4b to request structured AI suggestions.
The repository also includes a README with installation instructions, the API overview, troubleshooting guidance, and the project's roadmap.
How I Built It
The central idea was to build around an open-weight model rather than making a hosted AI service a mandatory dependency.
Here's the architecture:
User
|
v
+----------------------+
| React + TypeScript |
| LazyDesk AI UI |
+----------------------+
|
v
+----------------------+
| Python + FastAPI |
| Local API |
+----------------------+
|
v
+----------------------+
| Ollama |
| Local inference |
+----------------------+
|
v
+----------------------+
| Gemma 3 (4B) |
| File metadata |
| analysis and ideas |
+----------------------+
|
v
+----------------------+
| Structured AI |
| suggestions |
+----------------------+
1. The interface
I built the frontend using React and TypeScript, with Vite for development. The interface is organized into separate pages so that the project can grow beyond a single file-upload screen.
2. The backend
FastAPI provides the API layer. The health endpoint checks whether Ollama is reachable and whether the configured model is available. The analysis endpoint accepts a filename, extension, and file size, then sends a prompt to the local model.
3. The open-weight model
I chose Gemma 3 (4B) and run it through Ollama.
The model receives file metadata rather than needing the entire file's contents for the current analysis workflow. It is asked to return a structured suggestion that the application can use.
4. Working within real hardware limits
I developed this on a laptop without a dedicated GPU. That made local inference speed an important practical consideration.
It also made the project more interesting: I wanted to explore how useful local AI could be on everyday hardware, rather than assuming everyone has access to an expensive GPU or a paid cloud API.
The current version is a foundation. Connecting real folder selection, adding safe rename and move operations, and measuring performance are still part of the work ahead.
Why Does Open Innovation Matter?
For this project, open innovation isn't just a way to avoid a paid API. It changes the way the application can be built.
1. More control over personal data
File names can reveal a surprising amount about someone's life: academic work, job applications, personal documents, and projects.
With local inference, the model can process the metadata on the user's own machine. The intended workflow does not require sending that metadata to a third-party AI API. Of course, the actual privacy guarantees still depend on how the application is configured and implemented.
2. No mandatory per-request AI bill
Once the model is downloaded, local inference doesn't require paying a hosted AI provider for every request. Electricity, hardware resources, storage, and setup still have costs, but experimentation becomes much more accessible.
3. Freedom to experiment
Using an open-weight model makes it possible to explore different prompts, change the model, and test different approaches without rebuilding the application around a single closed provider.
4. AI that's closer to the user
A local-first design can reduce dependence on internet connectivity for inference after the model has been downloaded and the local services are running.
For a utility that deals with personal files, that is a meaningful design choice.
Open innovation made it possible for me to experiment with a practical AI-powered desktop utility while learning how the UI, API, and local model work together.
My Agent Session
I used AI-assisted development while building the interface and project structure.
I haven't included a DevRelay session link because I don't have a verified public session URL to share yet. I'd rather leave that out than publish a link that doesn't work.
The Lazy Payoff 🦥
The payoff I'm aiming for is fewer repetitive decisions.
Imagine a folder containing files like:
notes_final.pdf
notes_final_v2.pdf
IMG_20261021_104533.png
download (7).pdf
A future end-to-end version of LazyDesk AI could inspect the metadata, suggest clearer names, and group related files for the user to review.
For example, it might suggest a more descriptive filename for a lecture PDF or recommend grouping screenshots separately from documents.
Those are illustrative examples of the intended workflow, not claims of measured results from the current prototype.
I haven't measured time saved yet. My next step is to test the workflow with a real folder, compare the manual process with AI-assisted suggestions, and record how long each takes.
Because saving time should be demonstrated, not just promised.
Prize Categories
- Best Use of Gemma — using Google's Gemma 3 open-weight model through Ollama for local AI-powered file metadata analysis.
I'm entering only the category that directly matches the technology used in this project.
Final Thoughts 💜
LazyDesk AI started with a small idea: what if organizing digital clutter didn't always require another round of manual effort?
Building it has given me an opportunity to explore local inference, open-weight models, API integration, and the practical challenges of making AI useful on everyday hardware.
It isn't finished yet, and that's part of the journey. The next challenge is turning the prototype into a reliable workflow that works with real folders and gives users control over every change.
Because sometimes productivity doesn't mean doing more.
Sometimes it means letting the computer handle a little more of the boring stuff.
Build thoughtfully. Automate carefully. Stay a little lazy. 🦥
Top comments (4)
Hy how many Hackathon participate u?
I don't know about dev. I earliest joined it and builded first project using ai can u give more info about dev? Help me🙂
Heyy! 😊 I've participated in 4 challenges so far, and I'm learning something new with each one! This is my 4th challenge, and it's been a great way to explore AI tools and build projects. 🚀
DEV Community is a platform where developers share their projects, write articles, exchange ideas, and learn from one another. You can join challenges, showcase what you're building, and connect with other developers.
I'd suggest starting by exploring DEV.to, checking out community challenges, and sharing your own projects and learnings. Don't worry if you're a beginner—we're all here to learn and grow together! 💜✨
How to join your team?
You can simply join through github and contribute in this project