DEV Community: Alok Ranjan

SlothSort

Alok Ranjan — Sat, 24 Oct 2026 13:18:48 +0000

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

What I Built

SlothSort is a local-first AI file organizer. Choose a folder and it scans up to 100 top-level files, then suggests a category and a more descriptive filename. Review the suggestions and select which files to move into category folders.

It’s for anyone who wants a tidier downloads or documents folder without sorting everything by hand. The AI proposes changes; you stay in control.

Demo

SlothSort runs locally. Start it with Docker Compose, then open http://localhost:5173 in a recent version of Chrome or Edge. Choose a folder to see it in action.

Code

The project source is in this repository. To run it, follow the setup instructions in the README.

Repository link: https://github.com/aLok-1105/slothsort

How I Built It

SlothSort combines a React and Vite frontend with a Node.js and Express backend, packaged with Docker Compose. It uses the browser’s folder-access API to let you select a folder and apply approved moves.

For classification, the backend sends each file’s name and supported text content to Gemma 3 270M running locally through Ollama. It supports text extraction from TXT, Markdown, CSV, JSON, LOG, and text-based PDF files; images are categorized by extension, without OCR. After you download the model, classification runs locally without a cloud AI API. The initial model download requires internet access.

Why Does Open Innovation Matter?

Using an open-weight model with Ollama makes it possible to run classification on my own machine, rather than depend on a closed, cloud-hosted AI API. That gives users more control over where their file content goes and makes the project easier to inspect and adapt. SlothSort sends files to its local backend for classification, and only moves files after the user approves the suggestions.

I left out the optional agent-session and lazy-payoff sections because the repository doesn’t provide a session link or measured time savings.

Studyforge

Alok Ranjan — Sat, 17 Oct 2026 13:13:50 +0000

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

What I Built

I built Studyforge, a locally hosted assessment builder for teachers, professors, tutors, and other educators.

An educator enters course material or learning objectives, adds details such as the course, grade level, and student instructions, then chooses how many multiple-choice, short-answer, and long-answer questions to generate. Studyforge creates an assessment draft with an answer key, shows it in a browser preview, and exports a print-ready PDF. The PDF can be made as a student copy without answers or a teacher copy with the answer key on a separate page.

The intended users are educators who want to prepare classroom tests more quickly. Schools, tutoring centers, and individual teachers could use a tool like this, though Studyforge does not currently include billing or paid plans.

Demo

There isn’t a public deployment or video demo yet. You can run it locally by following the setup instructions in the README.

After setup, open http://localhost:8000 to try the assessment builder.

Code

https://github.com/aLok-1105/-studyforge

How I Built It

Studyforge is a Node.js and Express application. Its browser UI is served by the Express server, which also provides endpoints for generating assessment drafts and downloading PDFs.

For AI, it uses Ollama to run the Gemma 3 270M model locally. The app sends the educator’s source material to the local Ollama API, which returns the questions and answer key. PDFKit generates the downloadable assessment PDFs.

The model and dependencies need to be downloaded during initial setup. After that, question generation and the app’s main workflow can run offline on the same computer: no hosted inference API is required. The interface also loads Google Fonts when an internet connection is available; offline, it falls back to system fonts.

Why Does Open Innovation Matter?

Open-weight models and local inference make it possible to build an AI-assisted teaching tool without depending on a closed, hosted inference API. Educators can run the model on their own machine, avoid sending course material to a third-party AI service by default, and use the app without per-request hosted-model fees.

It also makes the stack more adaptable: users can configure a different Ollama model to suit their hardware or needs. Local inference does have trade-offs—the model must be downloaded first, generation depends on available hardware, and smaller models may produce content that needs careful review. Studyforge treats generated assessments as drafts, not as a substitute for an educator’s judgment.

Prize Categories

No partner categories selected. Studyforge uses Ollama and Gemma; I have not confirmed that either corresponds to an eligible partner category for this challenge.

WildQuest | Make room for outside.

Alok Ranjan — Sun, 11 Oct 2026 06:51:55 +0000

WildQuest — Hacktoberfest Open-Source AI Challenge

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

What I Built

WildQuest turns everyday activity ideas into small, real-world
adventures. Tell it what you want to do---such as taking a walk,
stretching, or birdwatching---and it uses AI to generate exactly three
personalized quests.

Each quest includes clear instructions, an estimated time, a difficulty
level, points, XP, and relevant safety notes. Users can mark quests
complete or undo completion, making it easier to turn an intention to
get outside into a short, achievable challenge.

WildQuest is designed for anyone who wants a little extra motivation to
step away from their screen and do something in the real world. It adds
a lightweight game loop to everyday activities without requiring an
account.

WildQuest runs locally and can work offline after setup. The web app
and AI inference run on your own machine through Express and Ollama, so
generating quests does not require sending prompts to a hosted AI API.
An internet connection is needed initially to install dependencies and
download the Docker image/model. Once those are available locally, you
can use WildQuest without an internet connection.

Current limitation: Quest completion is self-reported. The app does
not independently verify that a quest was completed.

Demo

The app can be run locally by following the setup instructions below.

Video demo: Add a demo video is available in GitHub repo.

Code

GitHub repository: https://github.com/aLok-1105/WildQuest

The project serves the responsive web interface and JSON API from a
single Express application.

How I Built It

WildQuest is built with a lightweight web stack and local AI inference:

Node.js and Express serve the web interface and the API.
Ollama runs the language model locally.
Gemma 3 270M (gemma3:270m) generates personalized activity sessions and quests on the local machine.
Zod validates the generated response structure before it is returned to the client.
HTML, CSS, and JavaScript power the responsive interface, quest display, completion controls, and reward totals.
Docker Compose helps start the Ollama service and pull the configured model.

How it works

The user enters an activity prompt with any useful details, such as duration, pace, location, or difficulty.
The frontend sends the prompt to POST /task on the local Express server.
The Express server asks the local Ollama model to generate an activity session.
The server validates the response structure and returns the session as JSON.
The interface displays exactly three quests, including instructions, estimated time, difficulty, rewards, and safety notes.
Users can mark quests complete or undo completion. Earned points and XP are kept in browser sessionStorage for the current tab session.

Because both the application server and model inference run locally,
quest generation does not depend on a remote AI API. After the initial
installation and model download, WildQuest can generate quests
offline, provided the local services are running and the model is
installed.

Run it locally

Requirements: Node.js 18.11 or newer and Docker Desktop.

An internet connection is needed for the initial dependency installation
and for Docker/Ollama to download the required model. After setup, you
can run the app locally without internet access.

npm install
docker compose up -d
npm start

Open http://localhost:8000 in your browser. The web server expects
Ollama at http://localhost:11434.

The Docker Compose setup pulls gemma3:270m when the Ollama service
starts, if the model is not already available locally. By default, the
app uses gemma3:270m. Set the OLLAMA_MODEL environment variable to
use a different model that is already available in Ollama.

API example

Send a request to POST /task:

{
  "prompt": "Plan a relaxed 30-minute walk through a leafy park"
}

A successful response contains session details, exactly three quests, an
empty bonus_quests array, and total available points and XP. Each
quest includes completion criteria and reward values.

Invalid or empty prompts return 400. Ollama connection errors or
responses that do not match the expected structure return 502.

Why Does Open Innovation Matter?

Open innovation makes it possible to build an AI-powered experience
without relying entirely on a closed, hosted model API.

WildQuest uses Gemma 3 270M through Ollama, so inference can run locally
on the developer's machine. This gives developers a practical way to
experiment with an open-weight model, inspect and adapt the surrounding
application, and build a working prototype without requiring a
hosted-model API key.

Local inference also makes offline use possible after the initial
setup. Users can generate quests without sending their prompts to a
remote AI service or depending on an active internet connection, as long
as the app, Ollama, and the model are installed and running locally.

Using a small model makes local experimentation more approachable. The
trade-off is that output quality and reliability can vary, so WildQuest
validates the response structure and keeps quest completion
self-reported rather than claiming that the AI verifies real-world
activity.

Chronicle | History by date

Alok Ranjan — Fri, 02 Oct 2026 11:59:16 +0000

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

What I Built

I built Chronicle | History by Dates, a local-first history revision application for a friend who is preparing for competitive exams.

One of the problems my friend struggles with is remembering important historical dates and the chronological order of events. There are hundreds of dates to remember while preparing for competitive exams, and repeatedly reading the same information doesn't always make it easier to recall.

So I built Chronicle around a simple idea:

Make history easier to remember by organizing it around dates and using AI to create useful memory aids.

Chronicle allows my friend to explore historical events by date and use AI to generate explanations and memory aids for difficult events.

Rather than building another general-purpose AI chatbot, I wanted to build something focused on a real problem faced by one particular person.

And there's one more important part:

Chronicle runs locally and can work offline.

After the initial setup and download of the AI model, the application doesn't need an internet connection to use its AI features.

The demo shows Chronicle running locally, including the AI functionality with the internet disconnected.

Demo

Code

GitHub: https://github.com/aLok-1105/chronicle

How I Built It

Chronicle is a lightweight web application built using:

Node.js — application runtime
Express.js — backend/server
HTML, CSS and JavaScript — frontend
Docker Compose — running the application and AI infrastructure
Ollama — local AI inference
Qwen2.5 0.5B — open-weight language model

The AI model I currently use is Qwen2.5 0.5B, which is only around 397 MB and can run locally on a regular laptop without a dedicated GPU.

The architecture looks like this:

┌───────────────────────────────┐
│        HTML / CSS / JS        │
│           Chronicle           │
└───────────────┬───────────────┘
                │
                ▼
┌───────────────────────────────┐
│          Express.js           │
│            Node.js            │
└───────────────┬───────────────┘
                │
                ▼
┌───────────────────────────────┐
│          Docker Compose       │
│                               │
│  ┌─────────────────────────┐  │
│  │         Ollama          │  │
│  │                         │  │
│  │    Qwen2.5 0.5B         │  │
│  └─────────────────────────┘  │
└───────────────────────────────┘

The user interacts with the normal web interface, while the Express backend communicates with the locally running Ollama instance.

There is no requirement to send the user's questions to a remote AI API.

Offline Mode

The first setup requires downloading the Docker images and the Qwen model.

After that, the complete application can run locally:

Internet
   │
   ✕
   │
   ▼
┌─────────────────────────────┐
│       Chronicle             │
│                             │
│ HTML/CSS/JS                 │
│      ↓                      │
│ Express                     │
│      ↓                      │
│ Ollama                      │
│      ↓                      │
│ Qwen2.5 0.5B                │
└─────────────────────────────┘

This means the AI functionality can continue working without an internet connection after the initial installation and model download.

Why Does Open Innovation Matter?

Open innovation is important to Chronicle because the project is designed around local AI rather than a closed cloud AI API.

I wanted to see how much could be built with a very small open-weight model running on an ordinary laptop.

Using Qwen2.5 0.5B with Ollama gives Chronicle several advantages:

Works offline after the initial setup
No AI API key required
No per-request API cost
User interactions can stay on the local machine
The model can be replaced with another open-weight model
I can customize prompts and AI behavior for competitive-exam preparation
The application isn't tied to a single cloud AI provider

The offline capability is particularly important to me.

A student shouldn't need a constant internet connection just to use an AI-powered study tool. With Chronicle, the model is downloaded once and can then run locally.

The project also demonstrates that local AI doesn't necessarily require an expensive GPU or a huge model.

I'm currently using a 397 MB Qwen2.5 0.5B model on a regular laptop with no dedicated GPU.

That makes experimentation much more accessible.

Instead of:

Student
   ↓
Internet
   ↓
Cloud AI API
   ↓
Answer

Chronicle can work like this:

Student
   ↓
Chronicle
   ↓
Local Qwen model
   ↓
Answer

For me, that's the biggest reason open innovation matters here: I have control over the model, the data flow, and the application.

Built for a Friend

Chronicle started with a simple conversation with my friend.

He's preparing for competitive exams and was having trouble remembering historical dates and putting events in the correct chronological order.

Instead of building a generic AI application and looking for a problem to solve, I started with his problem.

I wanted to build something small that he could actually use while studying.

The result is Chronicle:

History organized by dates, with a local AI companion to help make those dates easier to remember.

And because it runs locally, he can even use it when he's offline.

That's what made this project meaningful to me—not just building something with AI, but building something for someone I know and care about.