DEV Community: Md Mohid Hossain

SlothGhost

Md Mohid Hossain — Tue, 27 Oct 2026 08:43:08 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

👻 SlothGhost: The Ghosts Hiding in Your Files

What I Built

I built SlothTab, a local-first AI assistant that finds the forgotten things hiding on your computer.

Over time, our laptops accumulate thousands of files:

old projects
forgotten screenshots
university notes
unfinished ideas
random documents
old photos
abandoned code
files we haven't opened in years

Most of them aren't really gone.

They're just... forgotten.

That's where the idea for SlothTab came from.

I wanted to build an AI that could explore this digital clutter and bring the interesting pieces back to the surface.

Instead of asking:

"What files do I have?"

SlothTab asks:

"What have I forgotten?"

The AI scans a user-selected collection of files locally and creates connections between them.

It can:

👻 Find forgotten files
🧠 Understand document contents
🔗 Discover connections between files
📂 Group related projects and notes
📝 Summarize old documents
🔍 Find duplicates
💡 Resurface unfinished ideas
🕰️ Highlight files that haven't been opened in a long time
🔒 Keep the entire process local

The goal isn't to delete the digital clutter.

It's to give the forgotten parts of it a second life.

Demo

The demo starts with a folder containing a collection of old files.

SlothTab scans them locally and creates a Ghost Report.

For example:

👻 GHOST REPORT

I found something you might have forgotten.

────────────────────────────

📁 Project: "AI Study Assistant"

Last modified:
March 2025

Related files:
• project-notes.md
• architecture.png
• research.pdf
• prototype.py

Status:
⚠ Seems unfinished

────────────────────────────

📝 What I found:

You started building an AI study assistant
but never completed the prototype.

The project contains an architecture diagram,
research notes, and an unfinished Python file.

────────────────────────────

👻 Maybe this one deserves another look.

That's the moment I wanted SlothTab to create.

Not:

"Here are 47 files."

But:

"Hey... remember this?"

Code

💻 GitHub:https://github.com/neomon-dev/SlothTab.git

SlothTab is open-source and designed around local AI.

The AI provider is abstracted so users can run different open-weight models through local inference.

The project can work with:

LM Studio
Ollama
OpenAI-compatible local endpoints

The goal is to make the AI layer replaceable rather than locking the application to one provider.

How I Built It

SlothTab is built around a local-first AI pipeline.

The architecture looks roughly like this:

                 👻 SlothTab
                      │
                      ▼
                Local Files
                      │
                      ▼
             Document Processing
                      │
            ┌─────────┴─────────┐
            ▼                   ▼
        Text Files            Images
            │                   │
            └─────────┬─────────┘
                      ▼
                 Local AI
                      │
                      ▼
             Structured Analysis
                      │
            ┌─────────┼─────────┐
            ▼         ▼         ▼
        Summaries  Connections  Insights
            │         │         │
            └─────────┴─────────┘
                      ▼
                 Ghost Report

The frontend is built with React + TypeScript, with a Python/FastAPI backend and SQLite for local persistence.

For documents, SlothTab extracts information locally before passing relevant content to the configured local model.

The AI isn't given direct control over the filesystem.

Instead, it produces structured information that the application validates before doing anything with it.

For example:

{
  "title": "AI Study Assistant",
  "confidence": 0.91,
  "last_modified": "2025-03-12",
  "related_files": [
    "project-notes.md",
    "architecture.png",
    "prototype.py"
  ],
  "status": "unfinished",
  "summary": "An unfinished AI study assistant prototype.",
  "insight": "The project appears to have been abandoned before implementation was completed."
}

This makes the AI useful without giving it uncontrolled access to the user's machine.

Why Does Open Innovation Matter?

This project is particularly interesting as a local AI application because the files being analyzed can be deeply personal.

Old documents can contain:

personal writing
university work
private projects
photographs
financial documents
research
unfinished ideas

I didn't want the basic premise of the application to be:

"Upload your entire digital history to a cloud AI."

Instead, SlothTab is designed around:

Your files
    ↓
Your computer
    ↓
Your local model
    ↓
Your insights

🔒 Privacy

The files can remain on the user's machine.

That's important when the AI is looking through years of personal data.

🌐 Offline AI

Once the model is installed, the core analysis can work without an internet connection.

The "ghosts" in your computer don't need to leave your computer to be understood.

🔄 Model freedom

SlothTab isn't tied to one AI provider.

Users can experiment with different open-weight models and choose the one that works best for their hardware.

🛠️ Customization

The AI's behavior can be changed.

Users can modify:

prompts
analysis rules
categories
similarity thresholds
what counts as "forgotten"
how insights are generated

That level of control is one of the things I find most interesting about open AI.

My Agent Session

[Add your DevRelay agent session here.]

I used an AI coding agent during development to help with implementation, debugging, architecture, and iteration.

The interesting part wasn't just getting the application to work.

It was being able to iterate on the entire idea—from a simple local file organizer into something that could actually understand the history hiding inside a computer.

The Spirit of It

The first time I saw an old project resurface, the experience was surprisingly different from a normal AI interaction.

It wasn't:

"Here's something AI generated."

It was:

"Wait... I made this?"

That's the feeling I wanted SlothTab to capture.

Our computers are full of digital ghosts.

A folder from an old semester.

A half-finished project.

A screenshot of an idea that never became anything.

A document written at 2 AM that we completely forgot about.

A repository that hasn't been touched since we thought we were going to build the next big thing.

They're still there.

They're just buried.

SlothTab gives those forgotten things a voice.

Not by pretending to know everything about you, but by finding patterns in the things you've already created and saying:

"You might want to look at this again."

And because the AI runs locally, those memories don't have to leave your machine to be rediscovered.

That's my interpretation of Ghost in the Machine:

The ghost isn't inside the AI.

It's inside the machine already.

SlothTab just helps you find it. 👻

Prize Categories

[Add the applicable partner categories here.]

👻 Final Thought

I started this project thinking about AI as something that creates new things.

SlothTab explores the opposite idea:

What if AI could help us rediscover the things we've already created?

Sometimes the most interesting thing on your computer isn't something new.

It's something old that you've forgotten.

And maybe it's time to open that folder again.

The ghosts have been waiting.

🦥 SlothTab: Let Local AI Handle the Boring Stuff

Md Mohid Hossain — Tue, 20 Oct 2026 18:07:07 +0000

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

🦥 SlothTab: Let Local AI Handle the Boring Stuff

What I Built

I built SlothTab, a local-first AI assistant for people who keep saying:

"I'll organize it later."

We all have that one folder.

Downloads full of:

IMG_8273.png
final_final2.pdf
document123.pdf
random screenshots
lecture notes
assignments
receipts
files we haven't opened in months

SlothTab lets you drop those files into an inbox and lets local AI figure out what to do with them.

It can:

📂 Categorize files
✏️ Give meaningless filenames useful names
🧠 Summarize documents
🏷️ Generate tags
📍 Recommend where files should go
🔍 Detect potential duplicates
⚠️ Identify files that may need attention
↩️ Undo file operations
🤖 Automatically process high-confidence files

Instead of spending 15 minutes organizing a folder manually, I can drop everything into SlothTab and let the sloth do the work.

The goal is simple:

Do less. Let AI handle the boring parts.

For example:

Before

Downloads/
├── IMG_8273.png
├── final_final2.pdf
├── cloudnotes.txt
├── receipt.jpg
├── document123.pdf
└── screenshot.png

After SlothTab:

College/
├── Cloud Computing/
│   └── cloud-computing-lab.pdf
│
└── Notes/
    └── cloud-computing-notes.txt

Screenshots/
└── cloud-console-screenshot.png

Receipts/
└── receipt.jpg

And hopefully the user is nowhere near the keyboard. 🦥

Code

https://github.com/neomon-dev/SlothTab.git

SlothTab is designed to be open and extensible, particularly around the AI layer.

The AI provider is abstracted so the application isn't tied to one model or one company.

You can use a local model through:

LM Studio
Ollama
another OpenAI-compatible local endpoint

That means the model powering SlothTab can be changed without rebuilding the entire application.

How I Built It

SlothTab is built around a local-first AI architecture.

The basic flow looks like this:

                 🦥 SlothTab
                      │
                      ▼
                Local files
                      │
                      ▼
             File text / image
                 extraction
                      │
                      ▼
              Local AI model
                      │
                      ▼
            Structured JSON
                      │
                      ▼
              Safety validation
                      │
                      ▼
          User approval / Auto Mode
                      │
                      ▼
             File organization

The frontend is built with React + TypeScript, while the backend uses Python + FastAPI.

SQLite is used for local persistence, including activity history and reversible file operations.

For document processing, SlothTab extracts information locally before sending the relevant content to the configured local model.

The AI doesn't directly control the filesystem.

Instead, it produces a structured recommendation such as:

{
  "category": "College",
  "subcategory": "Cloud Computing",
  "suggested_filename": "cloud-computing-lab.pdf",
  "suggested_destination": "College/Cloud Computing",
  "summary": "Instructions for a cloud computing lab.",
  "importance": "medium",
  "confidence": 0.94
}

The application validates that response before performing any operation.

This separation is important:

AI → Recommendation
       ↓
Validation
       ↓
Application
       ↓
File operation

rather than giving the AI direct access to shell commands or filesystem operations.

Why Does Open Innovation Matter?

This is probably the most important part of SlothTab.

A traditional cloud AI implementation could send my documents to a remote API every time I wanted to organize them.

For a tool dealing with personal documents, screenshots, assignments, receipts, and potentially sensitive information, I didn't want that to be the default.

With local/open-weight AI, SlothTab can instead work like this:

My files
   ↓
My laptop
   ↓
My local model
   ↓
My organized files

The files don't need to leave my machine.

🔒 Privacy

SlothTab is designed so that document processing can happen locally.

That's particularly useful for files that I wouldn't want to upload to an external AI service.

🌐 Offline capability

Once the application and model are installed, the core AI workflow can work without an internet connection.

The assistant doesn't need to call a cloud model just to decide where a PDF belongs.

🔄 Model freedom

I'm not locked into one AI provider.

I can experiment with different open-weight models and choose the one that works best for my hardware and workload.

🛠️ Customization

Because the model and prompts are under my control, I can change how SlothTab behaves.

Want different categories?

Change the configuration.

Want stricter confidence thresholds?

Change them.

Want a different model?

Swap it.

Want to modify the AI's reasoning workflow?

The code is there.

💰 No per-file API dependency

There is no requirement to pay a cloud API every time SlothTab processes another document.

The main computational cost is instead running the model locally.

That changes the economics of building small AI automations.

The Lazy Payoff

The entire point of SlothTab is to remove the tiny tasks that aren't difficult—but are annoying enough that we keep postponing them.

Instead of:

Find file
    ↓
Open file
    ↓
Understand file
    ↓
Choose folder
    ↓
Rename file
    ↓
Move file
    ↓
Repeat × 20

SlothTab turns it into:

Drop files
    ↓
🦥
    ↓
Review
    ↓
Done

The most satisfying metric isn't how fast the AI responds.

It's how little I have to do.

And that's what I wanted from this challenge:

an AI that rewards laziness rather than demanding more work from me.

Final Thoughts

Open AI isn't interesting to me simply because it's "free" or because I can run a model locally.

It's interesting because it gives developers a different set of possibilities.

With SlothTab, the AI can become part of the user's computer rather than another website the user has to send their data to.

The model can be swapped.

The prompts can be changed.

The application can work offline.

The entire pipeline can be inspected and modified.

And most importantly...

I don't have to organize my Downloads folder anymore.

The sloth has it covered. 🦥

Foodle

Md Mohid Hossain — Tue, 13 Oct 2026 16:22:34 +0000

🍜 Foodle — AI-Powered Menu Translator & Dish Explainer

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

What I Built

Foodle is an AI-powered menu translator designed to help travelers, international students, and food lovers understand restaurant menus in languages they may not speak.

Imagine visiting a restaurant in another country, looking at a menu full of unfamiliar dish names, and having no idea what to order. Foodle aims to solve that problem by helping users translate menus and understand what dishes might contain.

🍽️ What Foodle aims to offer

Menu translation: Translate menu text into a language you understand.
Dish explanations: Get understandable descriptions of unfamiliar dishes, including their ingredients, preparation, flavor, and spice level when the information is available.
Menu image processing: Extract text from a photo of a restaurant menu using OCR.
Restaurant Menu Studio: Help small restaurants prepare translated versions of their menus.
Export options: Save translated menu content in convenient formats.

Foodle is designed for two audiences: travelers who want to order with confidence and small restaurants that want to make their menus accessible to international customers.

💡 The Side Hustle Opportunity

The core idea is to make menu translation useful and accessible for everyday users, while exploring a potential paid offering for restaurants that need multilingual menus.

A possible business model is a free tier for individual travelers and a paid tier for restaurants that need more menu translations, editable menu drafts, and export options.

The goal is simple: make food easier to understand, wherever you are.

Demo

🚀 Live Demo: https://foodle.streamlit.app/

Code

💻GitHub Repository: https://github.com/neomon-dev/Foodle/tree/main

Foodle is being developed as a Python application with a focus on a simple user experience and a modular architecture.

If you try it out, feedback and contributions are welcome!

How I Built It

Foodle is being built with a Python-based application architecture.

The planned technology stack includes:

Python for the core application.
Streamlit for the interactive web interface.
Ollama with an open-weight language model for local AI inference.
OCR tooling to extract text from menu photos.
SQLite for locally stored translation sessions.
pytest for automated testing.

The application separates OCR, translation, dish explanation, data storage, and menu export into distinct modules. This makes the code easier to maintain and allows individual components to be improved independently.

The AI layer is intended to explain unfamiliar dishes in simple language rather than merely translating their names. It must also communicate uncertainty instead of inventing ingredients or making unsupported allergy-safety claims.

The exact model and supported capabilities depend on the model installed and the features successfully implemented in the final version.

Why Does Open Innovation Matter?

Open innovation makes projects like Foodle possible for developers who want to experiment with AI without depending entirely on proprietary APIs.

Using open-weight models with local inference can offer several advantages:

More control: Developers can choose and configure the model that fits their needs.
Privacy potential: Menu text can be processed locally when the complete application and model are configured for local inference.
Lower dependency on external services: Local inference can reduce reliance on third-party AI APIs and their usage limits.
Experimentation: Developers can test different models and improve prompts and workflows.
Accessibility: Open-source tools make it easier for students and independent developers to build useful AI applications.

Open innovation is not just about making the code available. It is about giving more people the opportunity to understand, modify, and build on AI technology.

For Foodle, that means exploring how open AI can make everyday experiences—like ordering food in an unfamiliar place—a little easier.

Prize Categories

Render
TabPFN
Tinker
Arduino

Backboard

Building Foodle has been an opportunity to explore how open AI can solve a practical problem while leaving room for a sustainable product.

If you have ever struggled to understand a menu while traveling, I'd love to hear what features would make a tool like this genuinely useful to you!

Hacktoberfest #OpenSourceAI #Python #Streamlit #Ollama #AI #BuildInPublic

Naturechamp AI 🌿: An Open-Source AI Companion That Gets You Outside

Md Mohid Hossain — Sun, 11 Oct 2026 17:00:30 +0000

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

What I Built

🌿 NatureChamp AI is an AI-powered outdoor companion designed to help people spend less time scrolling and more time exploring the natural world.

Instead of using AI just to answer questions on a screen, NatureChamp turns curiosity into real-world activities.

With NatureChamp AI, users can:

🌳 Generate outdoor missions based on their available time, environment, and interests.
🤖 Ask an AI companion questions about nature, plants, birds, and ecosystems.
📸 Explore plant and bird identification through a photo-based discovery feature.
📓 Record observations in a nature journal.
🏆 Track completed missions, outdoor minutes, and achievements.

The idea is simple: prepare with AI, put the phone away, and explore!

The project is designed for students, nature enthusiasts, hikers, gardeners, and anyone who wants to reconnect with the outdoors.

Deployment

https://naturechampai.streamlit.app/

Code

GitHub Repository: https://github.com/neomon-dev/NatureChampAI.git

The repository contains the application source code, setup instructions, AI integration, and project documentation.

Contributions, feedback, and suggestions are welcome!

How I Built It

I built Nature AI using Python and Streamlit, with a focus on making open-weight AI a meaningful part of the experience.

My planned technology stack includes:

Python for application logic.
Streamlit for the web interface.
Ollama for running compatible open-weight language models locally.
Qwen or another compatible open-weight model for nature-related conversations and mission generation.
SQLite for local journaling and progress tracking.
pytest for testing.

The AI layer is designed to be modular, allowing different compatible models to be tested and substituted.

The application also includes a rule-based fallback for outdoor missions, so essential mission functionality can remain available when the local AI model is unavailable.

My goal is to make the experience useful without requiring a paid AI API.

Why Does Open Innovation Matter?

For me, open innovation is about having the freedom to build, experiment, and decide how AI should work.

Using an open-weight model with local inference can offer several important advantages:

🔒 Privacy: Nature-related questions and locally processed photos can stay on the user's device instead of being sent to a third-party AI API.

📴 Offline potential: Once the model, dependencies, and required assets are downloaded, supported features can work without an internet connection.

🔧 Flexibility: Developers can experiment with different compatible models, customize prompts, and change the application's behavior without being locked into a single closed AI provider.

💰 Accessibility: Local inference can avoid per-request API fees, although it still requires suitable hardware and uses electricity.

Open innovation also makes learning more accessible. Developers can inspect the architecture, understand how the AI integration works, and build on existing tools.

Most importantly, I want AI to encourage people to experience the world around them instead of keeping them glued to their screens.

The best outcome isn't another hour spent chatting with AI. It's a walk outside, a bird discovered, or a new plant learned about.

Prize Categories

Render
Github
Tabpfn
Tinker

Built with curiosity, Python, and a little help from open-source AI. 🌱

Let's touch grass!