DEV Community: swastika

TabJanitor — Less Tabs. More Focus. 🧹

swastika — Mon, 26 Oct 2026 06:59:20 +0000

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

What I Built

Ever opened your browser to do one task and ended up with 40 tabs, three YouTube videos, a dozen research articles, and no idea where anything is?

Meet TabJanitor — a local AI-powered Chrome extension that helps turn browser tab chaos into an organized workspace.

Instead of manually sorting through every tab, TabJanitor analyzes the tabs in your current browser window and suggests categories such as:

💻 Development — documentation, repositories, and coding resources
🎓 Study — notes, tutorials, and learning materials
🔎 Research — articles, references, and papers
🛍️ Shopping — products and comparisons
🎬 Entertainment — videos and social sites
🗂️ Junk / Review — tabs worth a second look

You stay in control throughout the process. Review the AI's suggestions, change categories, select the tabs you actually want to close, and approve the organization before anything happens.

No surprise tab closures. No automatic actions behind your back.

Code

GitHub repository: https://github.com/ivy1o1/TabJanitor

TabJanitor is built as a Chrome Extension using Manifest V3, with local AI inference for tab classification.

## How I Built It

TabJanitor combines Chrome's native browser APIs with Gemma 3 1B, an open-weight AI model that classifies browser tabs locally.

How we used Gemma

Gemma is the intelligence behind TabJanitor's tab organization suggestions. Instead of relying only on hardcoded rules or keyword matching, we use the model to interpret tab metadata and recommend useful categories.

Here's how the process works:

Collect tab metadata: The extension retrieves tabs from the current browser window.
Sanitize the input: It prepares minimal metadata, including tab titles and sanitized URLs, while keeping actual browser tab IDs local.
Classify with Gemma: The metadata is sent to Gemma 3 1B through a local llama.cpp / llama-server inference endpoint. Gemma returns structured classification suggestions, including categories and confidence information.
Validate the response: The application checks the model output against the expected schema and allowed categories before accepting the suggestions.
Let the user decide: Users can review the results, change categories, and explicitly select tabs for closure.
Apply only after approval: Chrome's native tab-grouping APIs organize the tabs only after the user confirms the plan.

Why Gemma 3 1B?

We chose a small model because TabJanitor is designed around local inference, including the constraints of everyday hardware. Gemma lets us experiment with AI-powered classification without making a hosted, paid API a requirement for the core workflow.

Running it through llama-server also gives the extension a local inference endpoint that it can communicate with, while keeping model inference separate from browser actions.

The rest of the stack

Chrome Extension Manifest V3 — extension architecture and permissions.
Chrome Tabs and Tab Groups APIs — reading tabs and creating native browser groups.
Gemma 3 1B — interpreting tab metadata and suggesting categories.
llama.cpp / llama-server — local model inference.
Schema validation and application logic — validating AI suggestions and enforcing explicit user approval.

The overall workflow is:

Scan → Sanitize → Classify with Gemma → Validate → Review → Approve → Organize

The important design decision is that Gemma recommends; the application validates; the user decides. The model doesn't directly execute browser actions or independently close tabs.

Why Does Open Innovation Matter?

A tool that organizes your browser shouldn't require sending your browsing history to a third-party AI service.

Using an open-weight model and local inference makes a different approach possible: run the classification locally, inspect how the system behaves, and build around privacy and user control instead of depending on a closed, hosted API.

Open innovation also makes experimentation more accessible. I can test the model, adjust validation, investigate failures, and build a useful workflow without making a paid API the foundation of the project.

For TabJanitor, openness isn't just about the technology. It's part of the product's design philosophy: your browser, your data, your decision.

My Agent Session

Building TabJanitor involved breaking the problem into smaller pieces: browser-tab collection, metadata sanitization, AI classification, review-plan validation, and explicit user-approved organization.

Each part has a defined responsibility, so the AI can suggest what to do without directly controlling browser actions.

The Lazy Payoff

The aim is to replace the tedious process of opening, inspecting, grouping, and closing tabs one by one with a single reviewable workflow.

Rather than promising an arbitrary number of minutes saved, TabJanitor focuses on reducing repetitive effort while avoiding the cost of accidentally closing a tab you still need.

Less tab chaos. Less manual sorting. More focus.

RedactIt: Redact Sensitive Documents with a Local Gemma Model, No Cloud Needed

swastika — Mon, 19 Oct 2026 06:28:43 +0000

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

What I Built

RedactIt is an AI-assisted document redaction tool designed to make removing sensitive information from documents more intuitive.

Redacting a document sounds simple until you have to identify exactly what should be removed without accidentally hiding information that needs to stay. Manually reviewing documents can be tedious, and overly broad automated redaction can remove important context.

I wanted to explore a different approach: what if you could describe what you want to redact in plain English, review the suggested matches, and stay in control of the final result?

That's the idea behind RedactIt.

The intended workflow is straightforward:

Provide a supported document, such as a PDF or DOCX.

Describe what should be redacted using natural-language instructions.

Let the AI-assisted pipeline interpret the instruction and identify potential matches.

Review the proposed redactions before approving or rejecting them.

Generate the redacted document through the existing processing pipeline.

RedactIt is being built around human review rather than blindly trusting an AI-generated result.

Who could use it?

Potential users include freelancers handling client documents, small teams processing business paperwork, researchers working with sensitive information, and professionals who need to prepare documents for sharing.

These users may value a tool that reduces repetitive review work while keeping them involved in decisions about what gets removed.

For a potential side hustle, I'm interested in exploring a practical model: a useful free or self-hostable tool, with paid options for teams that need a smoother workflow, integrations, or additional document-processing capabilities. That's a possible direction, not an established busness model or paying-customer claim.

Demo

https://redact-it-1.onrender.com

Code

GitHub repository: https://github.com/ivy1o1/Redact-It

The project focuses on the pipeline behind instruction-based redaction, rather than simply wrapping a chatbot around a file upload.

How I Built It

The central technical challenge was figuring out how to combine natural-language understanding with predictable document-processing behavior.

RedactIt uses a backend-driven pipeline with a configured Gemma model integration, candidate matching, evaluation, and validation.

At a high level, the workflow looks like this:

The exact verification and processing capabilities depend on the supported document type and the existing pipeline.

One important design decision was to avoid letting the language model independently decide to redact arbitrary content without constraints. Candidate matching and evaluation help connect proposed redactions to evidence from the document, while human review provides an opportunity to catch mistakes before finalizing the result.

This is especially important for redaction: removing too little can expose information, but removing too much can make a document useless.

I also built and tested the backend workflow, including model integration tests. The next priority is making the frontend experience feel as seamless as the underlying workflow: clear instructions, understandable results, and explicit control over proposed redactions.

Why Does Open Innovation Matter?

For a project like RedactIt, open innovation matters because document processing can involve information people would rather not send to an external AI provider.

Using an open-weight model such as Gemma gives developers more control over model selection, deployment architecture, and how inference fits into an application.

It also makes experimentation possible. Instead of treating an AI API as a black box, I can investigate how model output interacts with candidate matching, validation, and the rest of the processing pipeline.

There are trade-offs, of course. Running a model requires suitable infrastructure, and an open-weight model does not automatically make an application private, secure, or accurate. Those properties depend on the complete system, including where documents are processed, how data is handled, and how results are validated.

For me, the interesting part is being able to build and inspect the entire workflow instead of relying on a single closed API call.

My Agent Session

Optional: I'll add a DevRelay agent session here if I have a saved session that demonstrates the development process.

Prize Categories

I'll select the partner categories that match the actual technologies and tools used in this submission.

RedactIt is an ongoing project, and the goal is to make document redaction more approachable without hiding the decisions that matter.

The principle I'm building around is simple: let AI help identify what should be removed, but keep people in control of what actually gets redacted.

I'd love feedback on the approach, especially from anyone who has worked on document processing, privacy tooling, or human-in-the-loop AI systems.

Outverse: Exploring the Hidden Patterns Behind Our World #devchallenge #hf26challenge

swastika — Sun, 11 Oct 2026 18:52:47 +0000

I'm building Outverse, an AI-powered exploration experience that encourages people to look beyond the obvious and discover the hidden patterns, forgotten stories, invisible systems, and human traces that shape our world.

This project is my entry for the Hacktoberfest Open-Source AI Challenge — Week 1: Touch Grass.

🌱 What I Built
Outverse is designed to turn curiosity into exploration.

Instead of treating AI as just another chatbot, Outverse uses AI to generate exploration missions around four pillars:

Hidden Patterns — Notice connections and patterns that might otherwise go unnoticed.
Forgotten Stories — Explore stories and perspectives that deserve more attention.
Invisible Systems — Understand the systems shaping everyday life.
Human Traces — Look for the human experiences and traces behind the world around us.
Users can generate missions and submit reflections for AI-powered analysis, making the experience about observing, thinking, and engaging with the world rather than simply asking an AI for answers.

🎥 Demo
https://outverse-touchgrass.vercel.app

💻 Code
GitHub repository: https://github.com/ivy1o1/Outverse

The repository contains the frontend and backend implementation.

🛠️ How I Built It
Outverse uses a modern web stack with a Python backend and an AI-powered generation and analysis pipeline.

Frontend: React, TypeScript, Vite, and Tailwind CSS.
Backend: FastAPI and Python.
AI: Google's Gemma model through the Google GenAI SDK.
Interface: A nature-inspired visual theme built around forest greens, moss, parchment, and warm orange accents.
The backend exposes endpoints for generating missions and analyzing reflections. The frontend communicates with these endpoints to deliver the exploration experience.

One important part of the implementation is keeping the AI integration behind the backend instead of exposing the model API key in the browser.

🌍 Why Does Open Innovation Matter?
Open innovation makes it possible for people with different skills, backgrounds, and perspectives to build on each other's work.

For a project like Outverse, that matters because exploration shouldn't be limited to one person's perspective. Open-source development gives other contributors the opportunity to improve the experience, challenge assumptions, add new ideas, and help make the project more useful.

I also see this challenge as an opportunity to learn by building a real application, working through integration issues, and sharing the process instead of waiting until everything is perfect.

🤖 My Agent Session
AI-assisted development has been part of my workflow, particularly when working through backend integration, model behavior, and frontend implementation.

But using an AI coding assistant isn't the same as having a finished product. I still need to test the application, understand the code, handle failures, and make sure the different parts work together.

For me, the goal is to use AI as a development tool while continuing to understand the system I'm building.

🏆 Prize Categories
I'm participating in the Hacktoberfest Open-Source AI Challenge.

This post documents the current direction and implementation of Outverse. I'll update it with the deployed demo and further progress as the project develops.

Unbox — Get Everything Out. Put Everything in Place.

swastika — Mon, 05 Oct 2026 06:59:28 +0000

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

##What I Built

I built Unbox, a voice-first productivity tool for a friend who constantly has ideas, tasks, meetings, reminders, and random thoughts bouncing around in their head — but doesn't always have the time or energy to organize them.

The idea was simple:

Don't make people organize their thoughts while they're having them.

With Unbox, you can simply open it and talk.

“Tomorrow I need to finish my DBMS assignment. Remind me to call Mom at 7. I also have a meeting with Rahul tomorrow.”

Unbox turns that messy brain dump into structured information:

✅ Tasks
📅 Events & meetings
🔔 Reminders
👤 People
💡 Ideas
❓ Uncertainties

The important part is that Unbox doesn't pretend to know things that weren't said.

If something is ambiguous, it can surface that uncertainty instead of quietly making something up.

The user stays in control: they can review, edit, delete, or confirm what Unbox understood.

The goal isn't to create another complicated productivity system.

It's to make capturing thoughts almost effortless.

Speak first. Organize later.

## Demo
First visit → Name → Voice capture → Transcript → AI organization → Dashboard → Actions

## Code
GitHub: https://github.com/ivy1o1/Unbox

## How I Built It
Voice Brain Dump
↓
Whisper
↓
Transcript
↓
Gemma
↓
Structured JSON
↓
Pydantic
↓
User Review
↓
SQLite
↓
Dashboard

Unbox uses React + TypeScript + Vite on the frontend and FastAPI + SQLAlchemy + Pydantic + SQLite on the backend.

Whisper handles speech-to-text, while Gemma 3 1B Instruct runs locally through llama.cpp to extract tasks, events, reminders, people, ideas, and uncertainties.

The key principle is:

AI proposes. The user decides.

Open-weight AI also keeps the system more inspectable and makes local processing possible for sensitive personal data.

## Why Does Open Innovation Matter?
Brain dumps can contain highly personal information. Using open-weight models makes local AI processing possible without relying entirely on closed APIs.

It also lets me understand and control the full AI pipeline—from model and prompt to validation and uncertainty handling.

Prize Categories

Best Use of Gemma — Unbox uses Gemma 3 1B Instruct locally through llama.cpp as its semantic extraction engine, turning brain-dump transcripts into structured tasks, events, reminders, people, ideas, and uncertainties.