DEV Community: Jainil Chavda

Sloth Sorter: an offline, low-RAM file tidier with undo

Jainil Chavda — Sun, 25 Oct 2026 06:00:00 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

Sloth Sorter is a command-line tool that tidies a messy Downloads folder so you don't have to. It sorts files into folders, optionally reads their contents to guess a better category, and can rename them. Everything runs offline on a low-end laptop.

It is built to be safe:

Dry-run by default. It shows a preview and moves nothing until you pass --apply.
It never deletes. It only moves and renames.
Undo with SHA-256 checks. Every move is logged in SQLite and can be reverted, and files that changed since the move are skipped.

Code

Jainil26 / sloth-sorter

Offline, low-resource AI file organizer. Sorts, renames and archives your messy Downloads folder with dry-run and undo. Open-source, no LLM or GPU needed.

🦥 sloth-sorter

An offline, low-resource file organizer CLI in Python 3.14. Sorts, cleans, and categorizes messy folders (like Downloads or Desktop) with collision safety, dry-run by default, intelligent embedding-based document classification, smart keyword renaming, and cryptographically verified undos.

Designed specifically for low-end laptops with limited CPU, memory, and disk space:

Zero Heavy ML Bloat: No PyTorch, no sentence-transformers, no LLMs. Uses Model2Vec static embeddings (minishlab/potion-base-8M, ~30MB).
Tiny Install Footprint: Total virtual environment disk space is only ~303MB.
Lazy Loaded: Runs without --smart never import or load Model2Vec.
Never Deletes User Files: Moves and renames only.
Dry-Run by Default: Nothing moves without explicit --apply.
Safe Undo with SHA-256: SQLite-backed batch log tracks moves and renames, verifies hashes before reverting, and prevents overwriting conflicts.

🏗️ How It Works: 3 Tiers

Sloth Sorter uses a fast, hierarchical, multi-tiered approach:

                      [ Incoming File ]

…

View on GitHub

How I Built It

My laptop can't run even a small LLM, so I used a three-tier pipeline that only reaches for AI when needed:

Rules: extension and filename patterns, free and instant.
Open-source embeddings (--smart): Model2Vec potion-base-8M (about 30 MB, CPU-only, no PyTorch) embeds the first ~2000 characters of a file. NumPy cosine similarity against category prototypes picks the category.
Keyword renaming (--rename): a small built-in TF-IDF extractor builds names like 2026-03_electricity_invoice.pdf.

Stack: Python 3.14, Model2Vec, NumPy, PyMuPDF, python-docx, Rich, SQLite, pytest (44 tests passing). I built it over three days with Antigravity.

Benchmark on 30 synthetic documents: about 18 files/s, 191 MB peak RAM, 5 s model load (it includes the first-time download), 100% accuracy.

Why Does Open Innovation Matter?

Privacy: it reads your personal documents (ID cards, certificates, fee receipts) and none of it leaves the machine.
Runs on weak hardware: an open static-embedding model needs no GPU and no large download, which a closed API-based approach would not give me.
Zero cost: no API key or per-file billing, and it works offline after the first model download.
Swappable: categories and prototypes are plain config, so anyone can retrain them for their own files.

The Lazy Payoff

On my real Downloads folder (503 files), a single dry-run produced a full plan and a CSV report in seconds. 431 files were sorted by rules alone, and the embedding tier handled the other 72.

Honest limitations

The 100% score is on synthetic files written to match the prototypes. On my real, messy Downloads, the embedding tier was much weaker. For example, lecture PDFs landed in "Resumes", and a software license landed in "Invoices". I only reviewed these by filename, so treat this as a rough observation, not a measured accuracy.
Keyword renaming on real files was often unhelpful, so --rename is experimental.
The venv is about 303 MB, mostly PyMuPDF (172 MB). Swapping it for pypdf would shrink it.
Planned next: a stricter confidence threshold, keyword gates for risky categories, and a watchdog auto-sort mode.

Tablespeak: a menu translator that spells every dish the way the restaurant does

Jainil Chavda — Sat, 17 Oct 2026 10:31:06 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

Tablespeak is a menu translator for restaurants. You paste a menu in Gujarati, Hindi, English or a mix, pick one of 10 languages, and get a printable menu card.

The part someone would pay for is the glossary. A generic translator guesses dish names. It turns ઊંધિયું into "mixed vegetable curry" and spells khaman three different ways on one menu. With Tablespeak, the owner writes one line per dish:

ઊંધિયું / undhiyu | Undhiyu | Surat's winter specialty: mixed vegetables slow-cooked with green masala

Every matching dish then keeps that exact spelling and description, in every language. Dishes from the glossary get a small turmeric dot on the card, so the owner can see what came from their own dictionary.

The target customer is a small restaurant that wants a menu for tourists, or for staff and customers who read a different Indian language, without paying a translator for every edit.

Live demo: https://tablespeak.vercel.app
Code: https://github.com/Jainil26/tablespeak

How it works

The browser sends the menu and glossary to a small Node server. The server builds a prompt, calls an open-weight model through an OpenAI-compatible API, and returns a menu card. The API key stays on the server, so visitors never see it.

The whole project has zero dependencies: plain HTML, CSS and JavaScript, plus about 100 lines of Node. I built it in two days using Google Antigravity.

Why open models mattered here

I don't own a powerful laptop, so I couldn't run a model locally. Open weights still helped, because they are served by many providers through the same API. I used Qwen 2.5 72B, Llama 3.3 70B and Gemma 3 27B through OpenRouter, and switching between them is a dropdown in the app and one line in the code.

That mattered twice while building:

Free models disappear. Two of my three free model ids started returning 404 partway through, with an error saying the free version was gone. With a closed API that would have meant rewriting the integration. With open models I changed two ids in a config file and kept going.
Models are not equally good in every language. My first Punjabi test came back with English descriptions and English added in brackets next to the Gurmukhi headings. Because I could compare models and control the prompt, I fixed it in two steps: a script-aware prompt that tells the model which writing system to use, and a check on the server that detects when most descriptions are not in the right script and asks the model once more. After that, Punjabi came out correctly.

Other benefits of the open approach:

No lock-in. Any OpenAI-compatible endpoint works, so I can change the provider with one environment variable.
Private when it needs to be. The same code can point at a local Ollama server on a stronger machine, and a restaurant's menu data would never leave the building.
Cheap. A menu is a few thousand tokens, so a translation costs a fraction of a cent. [[ADD your real cost if you checked it on OpenRouter ]]
Customizable. The glossary and prompt are plain text, and open weights can be fine-tuned later for one cuisine.

What I learned from comparing models

[[ADD 2-3 honest lines from your own test: which model was best at Gujarati/Punjabi, which kept glossary names most exactly, which invented ingredients, and any speed difference. Even "Qwen was the best default" is fine. ]]

Limitations

Output is AI-generated, so the card tells readers to check ingredients and allergens before printing.
Open models are stronger in Hindi, Gujarati, Marathi and Bengali than in smaller-resource languages like Malayalam, Kannada and Telugu.
It translates menu text, not photos. Uploading a photo of a menu is the next feature I'd add.

Contribute

The repo is open for Hacktoberfest. Good first issues: glossary starter packs for other cuisines, more languages, CSV import and export for the glossary, and tests for the translation logic. Pull requests are welcome.

Thanks for reading!

[Boost]

Jainil Chavda — Sat, 03 Oct 2026 14:50:34 +0000

Hacktoberfest Weekend Challenge: Build for a Friend Submission 🤝

Jainil Chavda

Oct 3

I Built StudyBuddy AI for a Friend Who Was Tired of Turning Notes Into Study Material 📚🤖

#weekendchallenge #hf26challenge #devchallenge #ai

5 min read

I Built StudyBuddy AI for a Friend Who Was Tired of Turning Notes Into Study Material 📚🤖

Jainil Chavda — Sat, 03 Oct 2026 14:47:30 +0000

I Built StudyBuddy AI for a Friend Who Was Tired of Turning Notes Into Study Material 📚🤖

This is my submission for the Hacktoberfest 2026 Weekend Challenge: Build for a Friend.

Build something with open-source AI at its core.

Instead of building another generic AI chatbot, I wanted to build something practical for a student.

So I built StudyBuddy AI — an AI-powered study assistant that turns raw study notes into a structured study pack with summaries, key takeaways, practice questions, answers, and explanations.

👋 The Problem

A friend of mine often has the same problem before exams:

They already have the notes.

But then comes the difficult part:

What should I actually remember?
What are the important points?
What questions could be asked?
Can I test myself?
Do I really understand the topic?

Turning a large set of notes into useful revision material can take a lot of time.

I wanted to build something that could take those notes and immediately turn them into something that is actually useful for studying.

That's how StudyBuddy AI started.

🎓 What Is StudyBuddy AI?

StudyBuddy AI takes a student's study notes and transforms them into a structured Study Pack.

The student provides their notes, and the application generates:

📝 Summary
🔑 Key Takeaways
❓ Practice Questions
✅ Answers
💡 Explanations

The goal is simple:

Paste your notes → Generate a study pack → Revise → Test yourself

The demo shows the complete flow:

Enter study notes
Select an available AI model
Generate the study pack
Read the summary and key takeaways
Practice with generated questions
Reveal answers and explanations

🚀 Try the Project

GitHub Repository:

https://github.com/Jainil26/hacktoberfest-weekend-2026

🧠 How It Works

The architecture is intentionally simple.


text
Student
   ↓
React Frontend
   ↓
Express.js Backend
   ↓
Hugging Face Router
   ↓
Open-Weight AI Model
   ↓
Structured Study Pack
   ↓
React Interface


1. Student Input

The student pastes their study notes into the application.

2. Backend Processing

The React frontend sends the notes to the Express.js backend.

3. AI Processing

The backend creates a structured prompt based on the student's notes.

The prompt is then sent to the Hugging Face Router.

4. Model Generation

An available open-weight AI model processes the notes and generates:

Summary
Key takeaways
Practice questions
Answers
Explanations
5. Study Pack

The generated content is returned to the React application and displayed in an organized interface.

🤖 Model Selection

The default model used by StudyBuddy AI is:

Qwen/Qwen2.5-72B-Instruct

But I didn't want to hard-code the application around a single model.

StudyBuddy AI also includes a dynamic model selector.

It discovers compatible models currently available through Hugging Face's inference providers and allows the application to work with available models.

This is useful because model availability through hosted inference can change.

Instead of presenting users with models that may not currently work with the configured inference service, the application can discover compatible options dynamically.

💡 Why Open-Weight AI?

Open-weight AI was an important part of this project.

StudyBuddy AI uses open-weight models through Hugging Face inference providers.

This approach provides several interesting possibilities:

🔄 Flexibility

The application isn't conceptually locked to one model.

Compatible models can be swapped depending on availability and requirements.

💻 Deployment Options

When hardware allows, compatible open-weight models can potentially be deployed locally instead of relying entirely on hosted inference.

🛠️ Developer Control

Developers have more control over the model and deployment environment.

🧪 Experimentation

Open-weight models make it easier to experiment with different models and AI application architectures.

💰 Cost Flexibility

Developers can choose between hosted inference and self-hosted deployment depending on their requirements.

For StudyBuddy AI, this means the AI layer can evolve independently from the rest of the application.

🛠️ Tech Stack
Frontend
React 18
Vite
Vanilla CSS3
Lucide Icons
Canvas Confetti
Backend
Node.js
Express.js
CORS
Dotenv
AI
Hugging Face Router
Hugging Face Inference Providers
Qwen/Qwen2.5-72B-Instruct
📂 Project Structure
hacktoberfest-weekend-2026/
│
├── client/
│   ├── public/
│   │   └── logo.jpg
│   │
│   └── src/
│       ├── components/
│       │   ├── AboutModal.jsx
│       │   ├── FlashcardQuiz.jsx
│       │   ├── ModelSelector.jsx
│       │   ├── NoteInput.jsx
│       │   └── StudyPackView.jsx
│       │
│       ├── App.jsx
│       ├── App.css
│       └── main.jsx
│
├── server/
│   ├── aiService.js
│   ├── index.js
│   └── sampleNotes.js
│
├── .env.example
├── .gitignore
├── package.json
├── package-lock.json
├── README.md
└── ...
🧪 Example

Imagine a student has these notes:

TCP is a connection-oriented transport layer protocol.
It provides reliable and ordered delivery of data.
TCP uses acknowledgements, sequence numbers and retransmission
to ensure reliable communication between devices.

Instead of manually converting those notes into revision material, StudyBuddy AI can generate a structured study pack.

📌 Summary

A concise explanation of TCP and its purpose.

🔑 Key Takeaways
TCP operates at the transport layer.
TCP provides reliable data delivery.
TCP maintains ordered communication.
TCP uses acknowledgements and sequence numbers.
Lost data can be retransmitted.
❓ Practice Questions

The application generates questions based on the submitted study material.

✅ Answers & Explanations

Students can reveal the answers and explanations to check their understanding.

The idea is not simply to give the student an AI-generated summary.

It is to create a small revision + self-testing workflow from the material they already have.

🔐 Security

The Hugging Face API token is stored using environment variables.

Sensitive information should never be committed to the repository.

.env
API keys
Access tokens
Passwords
Private credentials

The .gitignore file is configured to exclude environment files and dependency directories.

🔮 What's Next?

There are several features I would like to add in future versions:

📄 PDF and document upload
🧠 Multiple study modes
🗂️ Dedicated flashcard generation
🎚️ Difficulty selection
📖 Detailed topic explanations
💻 Local model support
🤖 More Hugging Face models
📊 Study history
📈 Progress tracking
🔁 Spaced-repetition support

The current version intentionally keeps the core workflow simple.

❤️ Why I Built It

One thing I like about building AI applications is that the best ideas don't always need to be huge.

Sometimes the problem is simple:

"I have my notes. I just need a better way to study them."

StudyBuddy AI is my attempt to solve exactly that.

It combines a normal full-stack web application with open-weight AI to create something that can actually be used during everyday studying.

🧑‍💻 What I Learned

Building StudyBuddy AI gave me hands-on experience with:

Integrating AI models into a full-stack application
Working with Hugging Face inference
Building structured prompts
Dynamically discovering available AI models
Connecting React with an Express backend
Handling environment variables securely
Designing an AI-powered user workflow
Thinking about model flexibility instead of hard-coding a single model
🎯 Hacktoberfest 2026

This project was built for the Hacktoberfest 2026 Weekend Challenge: Build for a Friend.

The challenge focuses on building something with open-source AI at its core that solves a real problem for a friend or someone you care about.

For me, that problem was studying.

Instead of building a complicated AI system just for the sake of using AI, I wanted to build a small application where the AI component directly contributes to solving the problem.


🙌 Feedback Welcome

I'd love to hear what you think about StudyBuddy AI.

If you are a student, what feature would make a tool like this more useful for your study workflow?

And if you're a developer, I'd especially love feedback on the architecture, AI integration, and model-selection approach.

Built with ❤️ and open-weight AI for Hacktoberfest 2026.

![ ](https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/z1abbsvg5iv2q89pphpb.jpg)
![ ](https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/a5t6snmnsjg9l0m754mi.jpg)
![ ](https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/9ixr3kc516b4sd3m4sgl.jpg)
![ ](https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/8668w5r31jccoddi57mv.jpg)