DEV Community: Ankan Mahapatra

PageKeeper: A Little Bookmark for Your PDFs

Ankan Mahapatra — Sat, 24 Oct 2026 03:31:50 +0000

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

What I Built

I built PageKeeper, a browser-based PDF reader that remembers where you left off. Open a PDF once, and PageKeeper saves it in your browser so you can come back to your book and bookmark without searching for the file or finding your place again.

It supports single- and two-page reading modes, display-fitted pages, keyboard navigation, fullscreen reading, and a visible bookmark ribbon. Your PDF and reading preferences stay in your browser on your device.

Demo

Try PageKeeper: https://pagekeeper-2rvm.onrender.com/

Code

Explore the source on GitHub.

How I Built It

PageKeeper is built with HTML, CSS, and vanilla JavaScript. It uses PDF.js to render PDF pages and localForage to save PDFs in browser storage. The bookmark and two-page-view preference are stored in localStorage.

I used an AI assistant through Copilot SDK in VS Code to help implement and refine the project. The app itself does not use an AI model or make AI API calls; it runs as a lightweight, local-first reading tool.

Why Does Open Innovation Matter?

PageKeeper is built from open web standards and open-source libraries rather than a proprietary document-reading service. That makes the project easier to inspect, adapt, and build upon. It also means readers don’t need an account or a server to store their books.

Open tools made it possible to bring together focused, interoperable components: PDF.js handles document rendering, while browser storage keeps the reading experience personal and local.

The Lazy Payoff

When I return to a book, PageKeeper restores it and takes me back to my saved page. That means less time searching through files or scrolling to remember where I stopped—and more time reading.

OpenJEE: Flexible JEE Main Practice with Open-Source AI

Ankan Mahapatra — Sun, 18 Oct 2026 14:58:35 +0000

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

What I Built

I built OpenJEE, a JEE Main mock-test app for students who want on-demand practice without depending on a single AI provider.

Students can choose a subject, difficulty, test length, and question source. They can take a timed test, save answers for review, and see their score and step-by-step solutions afterward. Tests can come from a bundled question bank or be generated with an AI model.

The app is designed for JEE aspirants who want flexible practice: use the question bank for quick tests, a cloud model for generated questions, or run a model locally with Ollama.

Demo

Try OpenJEE

Code

View the OpenJEE repository on GitHub

How I Built It

OpenJEE uses FastAPI for its backend and serves a browser-based frontend built with HTML, CSS, and JavaScript. Pydantic models validate test questions and submissions. The frontend provides the timed exam experience, question navigation, browser-based session recovery, scoring, and solution review.

For AI-generated tests, I used LangChain to integrate Groq-hosted models and locally running models through Ollama. The app also includes a question-bank option that doesn’t require an AI provider. KaTeX renders mathematical notation in questions and solutions.

Why Does Open Innovation Matter?

Open innovation gives students a choice about where and how their practice questions are generated. With Ollama, a student can run a model locally instead of sending prompts to a cloud inference provider. That can be useful when privacy, internet access, or control over model choice matters.

The model-provider setup also avoids tying the app to one inference service. Students can use local inference, choose a hosted provider, or practice from the bundled question bank. That flexibility makes it easier to experiment with models and keep the basic practice workflow available even without a paid AI API.

TrailPacer AI — An Offline, Privacy-First Outdoor Pacing Engine

Ankan Mahapatra — Sun, 11 Oct 2026 16:52:18 +0000

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

What I Built

TrailPacer AI is an offline-first, local AI outdoor workout companion designed to do one thing ruthlessly well: get you off your screen and out into the dirt in under 15 seconds.

Modern fitness apps often demand constant screen time—tracking infinite metrics, loading social feeds, and requiring reliable cellular connectivity that disappears the moment you hit a real trail.

TrailPacer AI flips this dynamic. It leverages lightweight open-weight models running 100% locally on your machine to synthesize structured, phased outdoor workouts (Trail Walk, Fartlek Run, Rucking, and Interval Sprints) in under 3.5 seconds.

Once generated, TrailPacer switches to an outdoor Heads-Up Display (HUD) with high-contrast timers, target RPE (Rate of Perceived Exertion) gauges, terrain cues, and offline audio chimes—allowing you to pocket your phone, listen for pace transitions, and focus on the trail ahead.

Demo

Local Web UI & Companion Pacer: Runs locally at http://localhost:8000 with 0 external cloud dependencies.
Speed to Trail: Under 15 seconds from launching the app to lacing up your shoes.
Offline Audio Cues: Embedded Web Audio API chimes signal phase changes without requiring screen checks.

(Include your repo link, screenshots of the dashboard and HUD pacer, or a quick Loom / GIF demo here)

Code

ankan2526 / TrailPacer-AI

TrailPacer AI 🌲🏃‍♂️

TrailPacer AI is an offline outdoor workout companion powered by local AI. It synthesizes structured, adaptive training sessions for trail runners, hikers, and outdoor fitness enthusiasts in under 5 seconds—with zero internet connectivity required and minimal screen interaction time (< 15 seconds).

✨ Features

100% Offline: Runs completely on your device using open-weight local models (Llama 3.2 via Ollama). No cloud servers, no subscriptions, and absolute privacy.
Fast Generation: Generates complete phased workouts in under 5 seconds on modern laptops and Apple Silicon.
Structured Phases: Every session is broken down into structured warmup, main effort, and cooldown blocks with target RPE (Rate of Perceived Exertion) and terrain cues.
Built-in Offline Resilience: Automatically serves pre-calibrated workouts from local cache if the AI model is offline or busy.

🏃 Supported Activities

Trail Walk (trail_walk): Low-impact aerobic power walking and recovery hikes on variable terrain.
Fartlek Run…

View on GitHub

Key Project Architecture:

specs/: Formal JSON Schema contracts (workout_schema.json), functional requirements, and pre-compiled fallback caches.
src/agent.py: Local LLM prompt harness with temperature-constrained retry loops (0.1) and grammar-based structured schema enforcement.
src/validator.py: Strict schema validation engine.
src/app.py & src/static/: Vanilla zero-dependency dark-mode outdoor HUD with real-time audio chimes.
tests/test_workout_spec.py: Automated compliance test suite ensuring 100% schema adherence.

How I Built It

TrailPacer AI was developed using Spec-Driven Development (SDD):

The Contract First (specs/workout_schema.json): Defined a rigid Draft-07 JSON Schema enforcing activity types, phased duration blocks (warmup, main set, cooldown), target RPE ratings (1–10), and terrain suggestions.
Local Inference Engine: Powered by Ollama running open-weight quantized models (qwen2.5:0.5b for ultra-fast ~3s inference on CPU/Apple Silicon, with seamless configuration support for llama3.2:1b / llama3.2:3b).
Grammar-Constrained Structured Output: Instead of unconstrained generation, the schema is passed directly into Ollama's format parameter, leveraging GBNF grammar sampling to mathematically guarantee valid JSON output.
Resilience & Fallback Layer: If an inference daemon times out or fails schema validation, the agent automatically triggers a constrained retry at temperature=0.1. If offline without an active model server, it transparently serves verified, pre-cached routines from disk without breaking the runner's flow.
Zero-Dependency Companion Web App: A clean Python standard library HTTP server paired with a high-contrast outdoor UI (Vanilla HTML/CSS/JS) featuring Web Audio API chimes for auditory pacing.

Why Does Open Innovation Matter?

Open innovation is what makes TrailPacer AI possible. Here's why closed APIs couldn't solve this:

Trails Don't Have Cell Towers: Closed proprietary AI APIs (OpenAI, Claude, etc.) require an active internet connection. If you're at a remote trailhead, high in the mountains, or traveling in airplane mode, closed APIs are useless. Open-weight models run 100% offline directly on user hardware.
Zero Surveillance & True Privacy: Health and outdoor fitness data belongs to the athlete. Running open-source models locally guarantees zero telemetry, zero analytics tracking, and zero subscription paywalls.
Instant Latency: By pairing small open-weight models (qwen2.5:0.5b) with local quantization, workout generation takes ~3 seconds—faster than waiting for an API roundtrip over a spotty LTE connection.

Open-source AI transforms generative models from cloud services into dependable, local utility software that empowers people in the physical world.

Friend.py — A Beginner’s Python Learning Buddy

Ankan Mahapatra — Sun, 04 Oct 2026 16:13:29 +0000

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

What I Built

I built Friend.py, a beginner-friendly Python learning app for a friend who is just starting to learn programming.

It brings everything a beginner needs into one place:

a structured Python curriculum
lesson-based learning by topic
a chat tutor that explains concepts in simple terms
a quiz generator for practice
a code editor to write and test code
a sandboxed runner to execute Python safely
a reviewer that gives hints when code fails

This solves a real problem: many beginners have to jump across multiple tools and tutorials just to learn one concept. Friend.py keeps the learning flow in one app, so they can learn, practice, and clear doubts in a single place.

Demo

Deployed on Render: Friend.py

This app also works offline locally with Ollama, so it can be used without an internet connection.

Code

GitHub repo: Friend.py

How I Built It

I built Friend.py as a Streamlit app using a local-first open-weight AI architecture.

What powers it:

Streamlit for the browser interface
Open-weight local inference via Ollama
OpenAI-compatible client setup for local model access and cloud fallback
Custom curriculum and challenge system
Safe subprocess-based code execution with a short timeout and blocked unsafe imports

The app is designed so that:

locally, it connects to Ollama using the OpenAI-compatible endpoint
in Render, it automatically switches to Groq using the GROQ_API_KEY
the same learning experience works both offline and in deployment

The AI models used are:

Tutor and quiz generation: llama3.1:8b
Code review: qwen2.5-coder:7b

This makes the app practical for a beginner while also showing how open-source AI can be used without vendor lock-in.

Why Does Open Innovation Matter?

Open innovation matters here because it makes AI accessible, private, and flexible.

This project is built around open-weight models and local inference, which means:

the app can run offline
the user’s learning session stays private
there is no mandatory paid API dependency for local use
the project can be deployed anywhere without being locked into one provider

A closed API would have made this much harder to use for a beginner in a privacy-conscious, offline-friendly way. Open models made it possible to build a learning companion that works both locally and on Render, without sacrificing accessibility or control.

Prize Categories

Best Use of Render
Open Source AI

I shared this with a friend who is a complete beginner in Python, and he absolutely loved it. Before using Friend.py, he had to switch between multiple tools just to learn one concept: reading tutorials, searching for explanations, trying code examples somewhere else, and then figuring out what went wrong on his own. With Friend.py, everything is in one place. He can learn through structured lessons, ask questions to the tutor, practice in the built-in code editor, test his code instantly, and get beginner-friendly feedback when something fails.