DEV Community: Apurv

CampusBrain v0.1: A Local-First Academic OS Scaffold (React + FastAPI)

Apurv — Sun, 25 Oct 2026 22:37:22 +0000

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

What I Built

CampusBrain v0.1 is the foundational scaffold for a privacy-first, local academic operating system. It’s designed to unify attendance tracking, syllabus parsing, and assignment deadlines into one brutalist-inspired dashboard.

Embracing the "Slow and Steady" theme, this v0.1 MVP doesn't rush buggy features. Instead, it focuses entirely on establishing a robust, modular architecture with honest empty states. When Milestone 2 is complete, it will save students from checking five different college portals just to figure out what is due tomorrow, and let them be lazier by automating the dreadful math of "how many more classes can I skip before my attendance drops below 75%?"

Demo

Here is the foundational architecture running locally, showcasing the separated component UI:

The Executive Dashboard

The Chat Interface

Auth & Onboarding Flow

Code

krvnium / CampusBrain

🎓 CampusBrain v0.1

A Local-First Academic Operating System (React + FastAPI Scaffold)

Built for the Hacktoberfest 2026 Week 3 Challenge.

💡 The Vision

EdTech platforms frequently silo student data into proprietary ecosystems. CampusBrain is an open-source, local-first academic operating system that gives students total control over their schedules, attendance tracking, and document querying without surrendering their data.

🏗️ What is v0.1?

This repository contains the Foundational Architecture (Milestone 1) of CampusBrain. Before hooking up a database or API, I utilized AI coding agents to strictly separate concerns, establishing a modular React + TypeScript frontend and a validated FastAPI backend shell.

This scaffold abandons "mock data" entirely. The UI correctly renders responsive, accessible components with honest empty states based on the current date, proving the frontend routing and component architecture are structurally sound and ready for backend integration.

✨ Implemented Features (Milestone 1)

Modular React + TS Frontend: Clean component…

View on GitHub

How I Built It

I used AI coding agents to strictly separate concerns, establishing a modular React + TypeScript frontend (using Vite) and a validated FastAPI backend shell. The UI correctly renders responsive, accessible components without relying on hardcoded "mock" data.

By building this slow and steady foundation first, the codebase is now perfectly prepped for Milestone 2: porting over the local SQLite schema, PyMuPDF parser, and Gemma 4 open-weights AI integration that I successfully built during the Week 2 challenge.

Why Does Open Innovation Matter?

Student data—like attendance, grades, daily schedules, and location—is deeply personal. Open innovation allows us to build "local-first" scaffolds where the student entirely owns their database and inference. By leveraging open-weight models (like Gemma 4) to parse syllabus PDFs locally, students do not have to hand their academic records over to closed-source EdTech giants just to get an automated study schedule or a deadline reminder.

ScopeShield: A Local-First Freelance Contract Auditor

Apurv — Sun, 18 Oct 2026 19:39:43 +0000

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

What I Built

ScopeShield is a local-first Streamlit web app that helps freelancers detect "scope creep" in client requests without uploading sensitive NDAs to closed AI platforms. It uses PyMuPDF to parse local contract PDFs and an open-weights Gemma model to cross-reference client requests against the agreed deliverables. If a client asks for a feature not in the contract, ScopeShield flags it, calculates the extra cost using deterministic Python math, and logs a confirmed change order in a local SQLite database

Demo

Code

All of the codes are here.
https://github.com/krvnium/ScopeShield

How I Built It

I built ScopeShield as a modular, local-first Python Streamlit web application. For document processing, I used PyMuPDF to extract text from contract PDFs directly on the user's laptop, ensuring the files are never uploaded to a third-party server. For the core auditing logic, I integrated Gemma 4 (Google's open-weights model) via the google-genai SDK. I designed a strict JSON schema prompt that forces the open-weight model to classify the request (In Scope vs. Scope Creep), cite the exact page number, and estimate the additional hours. All financial calculations and confirmed change-orders are handled by deterministic Python logic and saved to a local SQLite database.

Why Does Open Innovation Matter?

Freelance Statements of Work (SOWs) contain highly confidential client data, proprietary pricing strategies, and strict NDAs. Uploading these legal contracts to closed-source, proprietary AI platforms is often a breach of client trust. By relying on local extraction and open-weight models like Gemma 4, freelancers can leverage powerful AI auditing without compromising their clients' privacy. Open innovation makes secure, enterprise-grade contract auditing accessible to solo developers who cannot afford expensive monthly SaaS subscriptions

CURSED.EXE — Touch Grass. Collect the Evidence. 🌿🎴

Apurv — Sat, 10 Oct 2026 18:38:51 +0000

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

What I Built

What if touching grass gave you loot?

Meet CURSED.EXE, a chaotic little project that turns ordinary things from the real world into collectible, AI-generated pixel-art trading cards.

The concept is simple: we spend so much time staring at screens that we sometimes forget the interesting stuff sitting right outside our doors. CURSED.EXE gives us a ridiculous excuse to go outside and look around.

Found a weird-looking tree? Photograph it.

Spotted a cat? Photograph it.

Found a suspicious banana in your kitchen? Unfortunately, that counts too. 🍌

Upload the photo, and CURSED.EXE transforms it into a collectible entity card featuring colourful, classic 16-bit RPG-inspired pixel art, an AI-generated name, a class, rarity, two randomized stats, a quirky one-liner, and completely unnecessary fictional lore.

Your banana might become Bananazon. Your cat might become Sprite. Your sandwich might become a level-one Gluten Shield mob from the Breakfast Sector.

I'm not questioning the AI's decisions anymore.

Every card joins your personal collection, turning ordinary observations into a growing bestiary of real-world anomalies.

The goal isn't to build another game that keeps people glued to their screens. It's to make the world outside feel a little more like an adventure.

Go outside. Find something weird. Capture the evidence.

Demo

GitHub repository: https://github.com/krvnium/cursed-exe

The project runs locally as a Streamlit application. The repository contains the source code and setup instructions.

The screenshots below are examples of cards generated during development:

A cat reimagined as a pixel-art RPG creature.

Jarvis, a household entity with a deeply concerning relationship with sandwiches.

Code

Explore the source code: krvnium/cursed-exe

The project is built with Python and uses Streamlit for the interface, Pillow for image processing and card rendering, and SQLite for the persistent collection.

The main pipeline looks like this:

Capture: Upload a photograph of something from the real world.
Pixelate: Process the image into a colourful, retro-inspired pixel-art representation.
Identify: Send the image through a vision-capable AI model to identify its subject and generate contextual metadata.
Randomize: Assign rarity and generate Chaotic-ness and Grass Meter stats.
Collect: Render the result into a custom trading card and save it to your collection.

The card images can be exported as PNGs, and the collection persists locally.

How I Built It

This project was a one-night experiment in getting an idea out of my head and into a working application.

I started with an initial implementation generated with Gemini, then used GitHub Copilot in Zed to inspect the codebase, debug the AI integration, improve the card renderer, redesign the interface, and prepare the project for GitHub.

The stack:

Python — application logic and metadata handling.
Streamlit — interactive web interface.
Pillow — image pixelation and trading-card rendering.
SQLite — persistent local collection.
Groq-hosted vision model — image understanding and generation of contextual entity metadata.
GitHub Copilot — agent-assisted debugging, implementation, and release preparation.

The interface uses a pastel NeoBrutalist aesthetic: thick black borders, offset shadows, a subtle grid background, pastel pink, lime and lavender, and Bricolage Grotesque typography.

The cards themselves follow a horizontal layout inspired by collectible trading cards, with the pixel art taking centre stage and the entity's stats and lore on the side.

One of the biggest debugging challenges was getting the AI integration working reliably. The configured endpoint was being constructed incorrectly, and the previous vision model configuration was unavailable. After correcting the configuration, I verified the integration with a real image inference request.

The project also preserves generated cards and their metadata locally, so your collection isn't supposed to change every time you reopen the application.

Why Does Open Innovation Matter?

For a small project like this, open innovation makes experimentation accessible.

I could combine an open development stack, a vision-capable model, image-processing libraries, and an AI coding agent without having to build every component from scratch.

Using an open-weight model through a hosted inference provider let me experiment with image understanding and structured metadata generation without needing to run a large model locally on my own hardware.

That distinction matters: the model is open-weight, while inference in this implementation is hosted rather than local.

Open-source libraries also made the rest of the project easier to understand, modify, and share. Someone else can inspect the pipeline, replace the model provider, change the card template, or extend the collection system instead of treating the whole application as a black box.

A closed API could also support this kind of project. The benefit of open innovation is not that closed systems are incapable of it; it's that accessible components and inspectable code give builders more freedom to experiment, learn, and adapt.

And that's exactly what this project was about: taking a silly idea and making it real in one night.

My Agent Session

I used Gemini for the initial code and GitHub Copilot in Zed for subsequent implementation, debugging, testing, and release preparation.

CURSED.EXE — Touch grass. Collect the evidence.

Now excuse me. I have a suspicious banana to investigate. 🍌

LearnCLI — an offline study tool I built on my phone for a friend prepping for JEE

Apurv — Sun, 04 Oct 2026 19:15:14 +0000

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

What I Built

A friend of mine is prepping for JEE and keeps hitting the same problem — she's studying somewhere with spotty internet, and every "AI study helper" out there needs a connection and usually a subscription. So I built LearnCLI: a tiny terminal tool that explains a topic and throws a practice question back at you, running fully offline.

You type a topic, it thinks for a few seconds, and it gives you a plain-text explanation plus one question to test yourself with. No account, no internet, no API bill.

The twist is I didn't have a laptop while building this. I did the entire thing on my phone, in Termux.

Demo

(this is a real run asking it to explain Newton's third law)

Code

Repo: https://github.com/krvnium/LearnCLI

How I Built It

Everything runs through llama.cpp, compiled straight from source inside Termux on my Poco M4 Pro. No GPU, no cloud box, just phone CPU.

For the model, I went with Gemma 3 1B, quantized down to Q4_K_M (~800MB), small enough that it actually runs at a usable speed on a phone.

The script itself is plain Python, calling the compiled llama-cli binary and cleaning up its output — stripping markdown symbols the model likes to throw in, cutting off a marker token I use internally to separate the prompt from the actual answer, and wrapping everything in a little terminal UI so it feels less like a raw model dump and more like an actual tool.

Build process, roughly:

pkg install the usual suspects (clang, cmake, git, python) in Termux
clone and compile llama.cpp natively on-device
pull the Gemma GGUF from Hugging Face
write the Python wrapper around it

Why Does Open Innovation Matter?

This only works because the model weights and the inference engine are both open. Gemma being open-weight means I can download it once and run it forever, no API key, no per-request cost, no "service unavailable" when my friend's hostel wifi dies at 11pm before an exam. llama.cpp being open-source is the other half — it's what let me actually get a transformer model running on a phone's CPU without needing anyone's permission or infrastructure.

A closed API would've meant my friend needs internet every single time she wants to use this, and I'd be the one paying for her queries. With this, I built it once, and it just works, offline, for free, for as long as the phone has battery.