DEV Community: Anirudha Basu Thakur

SlothDesk — Local-First AI Downloads Organizer: Less sorting. More living.

Anirudha Basu Thakur — Thu, 22 Oct 2026 05:29:34 +0000

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

🦥 What I Built

SlothDesk is a local-first, desktop-style dashboard that rewards laziness by safely organizing your cluttered Downloads folder with minimal user effort.

Tagline: Less sorting. More living.

Downloads folders are notorious black holes where productivity goes to die. Files of every kind—invoices, design assets, archives, code scripts, and firmware—pile up in an unmanageable mess.

Existing tools typically fall into two extremes:

Dumb regex scripts that break on edge cases and force rigid naming conventions.
Cloud AI utilities that upload your private documents and filenames to third-party APIs, charging recurring subscription fees.

SlothDesk charts a different path: Slow and Steady. It runs completely offline using Hugging Face smolagents and LM Studio (Qwen2.5-7B-Instruct), treating the language model as an untrusted reasoning engine rather than a reckless file manipulator.

Downloads/
├── Documents/
├── Images/
├── Videos/
├── Audio/
├── Archives/
├── Code/
└── Other/

🔒 The "Slow and Steady" Philosophy: Safety First

Many AI file organizers give the model direct write tools or shell access (CodeAgent, shutil.rmtree, os.rename). If the model hallucinates or encounters ambiguous context, files can be permanently destroyed.

In SlothDesk, filesystem mutation is architecturally separated from AI reasoning:

Zero Model Execution Privileges: The model has no write tools, cannot run shell commands, and does not execute dynamic Python scripts. It is given only 3 read-only metadata inspection tools:
- get_file_metadata(filename)
- get_allowed_categories()
- validate_category(category)
Strict Scope Confinement: Operations are locked strictly inside the configured SLOTHDESK_ROOT. Any path containing .., absolute drive letters, or symbolic links is immediately rejected.
Deterministic Collision Protection: If a destination file already exists or another file in the plan shares the name, SlothDesk safely resolves it to {name}_{counter}{ext} (e.g. invoice_october_1.pdf). Existing files are never overwritten.
Cryptographic State Check: At scan time, SlothDesk computes the SHA-256 hash and byte size of every file. At execution time, it re-verifies these hashes. If a file was modified or deleted while waiting for approval, the move is skipped to eliminate race conditions.
Reversible Manifests: Every approved move generates an immutable JSON audit manifest, enabling one-click rollbacks at any time.

📸 Application Showcase & Screenshots

1. Dashboard Overview

Inspect loose files in the Downloads folder, track storage volume, and verify the local inference engine status at a glance.

2. Read-Only AI Organization Proposal

Clicking Scan & Propose Plan triggers smolagents via LM Studio. Every file receives a color-coded category badge, destination path preview, model rationale, and automatic collision resolution.

3. Explicit Approval Gate

Zero files are altered until the user explicitly reviews the plan summary and safety checklist, confirming the moves in a dedicated modal dialog.

4. Downloads Inventory & Cryptographic Hashes

Inspect all top-level files with real-time size metrics, extension detection, and SHA-256 verification hashes.

5. Execution History & One-Click Undo

Every move produces an immutable JSON audit manifest. Click Undo Operation to instantly restore files back to their exact original root locations.

🛠️ Tools & Technologies Used

Python 3.11 & FastAPI: High-performance backend engine with Pydantic validation.
Hugging Face smolagents (ToolCallingAgent): Narrowly scoped, typed tool calling.
LM Studio: OpenAI-compatible local inference API running Qwen2.5-7B-Instruct (GGUF Q4_K_M) on consumer hardware (NVIDIA RTX 5050 Laptop GPU / 8 GB VRAM).
React 19 & TypeScript: Responsive dashboard interface with nature-inspired forest green aesthetics (#0a130e) and soft lime accents (#84cc16).
Vite 6: Client build tooling and reverse-proxy.
lucide-react: Lightweight icon set.
Podman: Rootless, containerized deployment workflow (infra/compose.yaml).
pytest: 28 automated unit, API, agent, and security tests.

🧠 Transparent Offline Fallback

A key requirement of SlothDesk is honesty:

When LM Studio is running, the dashboard displays Local AI: qwen2.5-7b-instruct with active tool reasoning.
When LM Studio is offline, SlothDesk automatically engages its deterministic rule fallback engine.
SlothDesk never falsely claims the AI model was used when the fallback was active.

This application was designed, implemented, and hardened pair-programming with Google Antigravity.

In accordance with DEV community guidelines, ai_disclosure_level: some_ai is declared for this submission.

Agent Workflow & Engineering Trajectory

Architecture & Threat Modeling: Designed the two-phase execution lifecycle strictly separating untrusted LLM reasoning from filesystem mutations.
Safety & Boundary Confinement: Built path canonicalization, symlink rejection, and deterministic collision policies (_1.ext) guaranteeing zero overwrites.
Agent Integration: Harnessed smolagents.ToolCallingAgent over local LM Studio endpoints (Qwen2.5-7B-Instruct) with transparent offline fallback.
Full-Stack Dashboard: Engineered a responsive React 19 + TypeScript interface with color-coded category badges and an unskippable approval modal gate.
Automated Verification: Authored 28 unit, API, agent, and security tests (pytest) and validated the production build.

🔗 Repository & Code

GitHub Repository: https://github.com/Ani0811/slothdesk
License: MIT
Architecture Deep-Dive: docs/ARCHITECTURE.md
Security Testing Report: docs/SECURITY_TESTING.md
Demo Walkthrough Script: docs/DEMO_SCRIPT.md

LocalBiz AI: A Local-First, Zero-Hallucination AI Marketing Copilot for Small Businesses

Anirudha Basu Thakur — Wed, 14 Oct 2026 14:56:42 +0000

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

What I Built

Small business owners—the neighborhood bakery, the artisan coffee roaster, the independent salon, the freelance photographer—face a severe marketing bottleneck. They work 12+ hour days managing inventory, baking bread, and serving clients. When it comes time to promote their business on Instagram, WhatsApp broadcasts, or Google Business Profile, they either run out of time or struggle with copywriter's block.

When local merchants turn to cloud AI tools like ChatGPT, they encounter two massive dealbreakers:

The Hallucination Trap: Generic cloud LLMs frequently invent fictitious discounts ("use promo code SAVE50!"), misstate menu prices, fabricate opening hours, or alter contact information. For a small business, publishing a wrong price or fake coupon directly erodes customer trust and costs real money.
SaaS Subscription Fatigue & Privacy Risk: Monthly subscriptions of $20–$50/seat eat into thin retail margins. Furthermore, small business owners do not want their customer lists, sales figures, and seasonal promotional strategies sent to third-party cloud data centers.

Enter LocalBiz AI 🚀

LocalBiz AI is a privacy-first, local AI marketing copilot engineered specifically for small businesses, freelancers, and neighborhood service providers.

It allows a business owner to:

Save their Business Truth: Store business category, location, exact hours, contact phone, website, and an itemized product catalog with verified prices and active offers.
Generate Factually Grounded Marketing Assets in Seconds:
- 📸 Instagram Captions with catchy hooks, body copy, and local hashtags.
- 📢 Promotional Sales Copy with verified discounts and compelling calls-to-action.
- 💬 WhatsApp Broadcast Messages formatted with clean bullet points and direct ordering links.
- 📍 Google Business Profile Updates optimized for local foot-traffic SEO.
- 🏷️ Product Catalog Descriptions ready for e-commerce or print menus.
- 📅 7-Day Weekly Content Plans mapping out daily pillars, channels, and hooks.
Multilingual Resonance: Native generation in English, authentic Bengali script (বাংলা), and natural conversational Bengali-English (Benglish) as widely used by local Indian and South Asian businesses.
Factual Shield: Automatically flags any unverified price or claim with visual warning banners.
One-Click History & Editing: Inline editing, clipboard copying, markdown download, and full revision tracking saved in local SQLite.

Who Would Pay For It?

Local Retailers & Cafes: Paying $15-$30/month for an offline "Marketing-in-a-Box" appliance that generates high-converting content with zero risk of price hallucination.
Social Media Freelancers & Agencies: Managing 10+ local client profiles from a single local workstation without paying per-token API charges.

Demo

Here is a look at LocalBiz AI in action:

1. Dashboard & Active Business Profile

Real-time overview displaying the active business profile ('Bengal Artisan Roast & Bake'), rapid creation actions, recent content activity, and the live LM Studio AI status badge.

2. Business Profile & Product Catalog Management

Structured profile manager where exact operating hours, location, contact channels, and itemized catalog items (with verified prices and active deals) are persisted in local SQLite.

3. AI Marketing Studio with Factual Accuracy Guardrail

Interactive generation studio with 6 format cards, offer picker, tone selector, language selector, and an editable preview protected by the Factual Grounding Shield.

4. Content History & Inline Editor

Full historical archive of generated marketing copy with channel filtering, instant copying, inline editing, and one-click reuse.

5. Local AI Diagnostics & NVIDIA CUDA GPU Acceleration

Diagnostic control panel showing live connection status to LM Studio, loaded model verification, and one-click commands for CUDA GPU offload.

Code

The complete source code is published on GitHub under the MIT License:

Ani0811 / localbiz-ai

🚀 LocalBiz AI — Local-First AI Marketing Assistant

LocalBiz AI is a privacy-first, local AI marketing copilot for neighborhood small businesses, cafes, bakeries, independent service providers, and freelancers. It turns saved business details, product catalogs, and promotional offers into high-converting, factually grounded marketing copy using open-weight models (google/gemma-3-4b, nvidia/nemotron-3-nano-4b) running locally on your hardware via LM Studio and Podman.

📸 Application Screenshots

Dashboard Overview	Business Profile Manager

AI Marketing Generation Studio	Saved Content History & Inline Editor

Real-Time AI Diagnostics & GPU Acceleration

🌟 The Problem & Who It Solves It For

Neighborhood bakeries, coffee shops, boutique fitness studios, salons, and local tradespeople face a painful daily dilemma:

Time-poor marketing: Small business owners work 12+ hours a day running operations and lack time to craft engaging daily posts for Instagram, WhatsApp, and Google Business Profile.
Cloud AI hallucination risk: Generic cloud LLMs frequently invent…

View on GitHub

Project Structure

localbiz-ai/
├── backend/                  # FastAPI 0.115 + Pydantic v2 Backend
│   ├── app/
│   │   ├── routers/          # REST endpoints (health, profiles, generate, history)
│   │   ├── schemas/          # Pydantic validation models
│   │   ├── services/         # LM Studio provider, prompt builder, factual guardrail
│   │   ├── config.py         # Resilient settings with field validators
│   │   ├── database.py       # Async SQLite with WAL mode & concurrency locks
│   │   └── main.py           # FastAPI app with CORS regex
│   └── tests/                # 15 automated Pytest unit & integration tests
├── frontend/                 # Next.js 15.1 + React 19 + Tailwind CSS Frontend
│   ├── src/app/              # Dashboard, Profile, Generate, History, Settings
│   ├── src/components/       # Navbar, dynamic AI Health polling badge
│   ├── src/lib/              # Typed API client & data interfaces
│   └── next.config.ts        # Standalone build with internal reverse proxy
├── containers/               # Production Podman Containerfiles
│   ├── Containerfile.backend # Python 3.12-slim with curl healthcheck
│   └── Containerfile.frontend# Node 22-alpine multi-stage standalone runner
├── compose.yaml              # Podman Compose orchestration
└── assets/screenshots/       # High-resolution screenshots & demo assets

How I Built It

LocalBiz AI is built strictly on open-weight models, native container orchestration, and local-first software engineering:

1. Local AI Inference with LM Studio & Open-Weight Models

Inference Engine: LM Studio running natively on the Windows host, exposing its OpenAI-compatible REST server (/v1/chat/completions and /v1/models) on port 1234.
Model: google/gemma-3-4b (3.34 GB quantized) and nvidia/nemotron-3-nano-4b (2.84 GB).
GPU Acceleration: Offloaded 100% of model layers to the host NVIDIA GPU (--gpu max), dropping generation time from ~45 seconds on CPU down to 1.8 seconds on CUDA.
Provider Isolation: The LMStudioProvider handles reasoning model structures (e.g., extracting final answers from Nemotron's reasoning_content), request timeouts (HTTP 504), and provides actionable 5-step terminal setup diagnostics if LM Studio is offline (HTTP 503). Core functionality never silently falls back to remote cloud APIs.

2. Prompt Engineering & Factual Accuracy Heuristics

The prompt builder constructs strict system prompts that instruct the model that the business profile is the sole source of truth.
Post-Generation Verification: A heuristic inspection compares the generated text against verified prices, discounts, and contact details from the business profile. If the model hallucinates an unverified price or external link, a warning badge is highlighted in the response and UI.

3. Containerization with Podman

Containerized into two dedicated services via Podman and Podman Compose:
- localbiz-backend: Python 3.12-slim running FastAPI with an asynchronous SQLite volume.
- localbiz-frontend: Node.js 22-alpine multi-stage build producing an optimized standalone Next.js server.
Host-to-Container Bridge: Configured compose.yaml with extra_hosts: ["host.containers.internal:host-gateway"] and LM_STUDIO_CONTAINER_BASE_URL so backend containers cleanly bridge to the LM Studio server on the Windows host.
SQLite Concurrency: Enabled SQLite Write-Ahead Logging (PRAGMA journal_mode = WAL;) and 15-second busy timeout (PRAGMA busy_timeout = 15000;) to eliminate locking under concurrent async requests.

Why Does Open Innovation Matter?

Open innovation is not just a philosophical preference—for local small business software, it is the only architecture that makes business and ethical sense:

Economic Viability for the 99%: A small bakery or barber shop operating on 5% profit margins cannot justify a $30/month cloud AI subscription that increases prices every year. Open-weight models running on existing shop hardware make AI assistance essentially free after download.
Data Sovereignty and Confidentiality: Small businesses handle sensitive customer contact numbers, proprietary ingredient ratios, supplier costs, and localized discounts. With local inference, their business secrets never leave their machine or train someone else's model.
True Offline Resilience: Local businesses often face unstable internet connections or ISP outages. LocalBiz AI operates 100% offline once the model and dependencies are installed.
Freedom from API Deprecation and Gatekeeping: Commercial LLM APIs change their weights, alter system prompts, filter commercial vocabulary, or deprecate endpoints overnight. Open-weight models like Gemma 3 and Nemotron remain permanently available and under the user's total control.

My Agent Session

This entire application—from initial repository initialization, FastAPI backend, Pydantic schemas, prompt design, Next.js frontend, Podman containerization, bug fixing (CORS, empty env vars, OCI healthchecks), to automated testing—was pair-programmed with Google DeepMind's Antigravity agentic coding assistant.

Key Milestones Driven with the AI Coding Agent:

Zero-Hallucination Prompt Architecture: Crafted strict system constraints enforcing the local business profile as the sole ground truth and designed post-generation heuristic checks for unverified prices and offers.
LM Studio Provider Isolation: Implemented a resilient provider handling both reasoning models (nvidia/nemotron-3-nano-4b) and standard models (google/gemma-3-4b), with timeout handling and 5-step actionable terminal diagnostics.
Multi-Stage Podman Architecture: Built production Containerfiles for FastAPI and Next.js standalone runner, container-to-host bridge routing (host.containers.internal), and persistent volume mounting.
Deep Concurrency & Network Debugging: Diagnosed and resolved subtle container issues including Pydantic empty-string float parsing, OCI health check polling in compose, and SQLite WAL concurrency locks.

My First User

During the Week 2 challenge build, I demonstrated the prototype to Debanjan M., co-owner of a neighborhood specialty cafe and artisanal bakery in Kolkata:

"Writing Instagram captions every morning after baking bread at 6 AM is the last thing I want to do. When I tried ChatGPT before, it kept inventing coupon codes that customers showed up demanding to use. LocalBiz AI actually sticks to our real menu prices ($6.50 sourdough, $4.50 cold brew) and writes in the exact natural Bengali-English mix our customers use on WhatsApp. Being able to run it locally on our shop laptop with zero monthly fee is a gamechanger."

Feedback incorporated:

Added the Bengali-English (Benglish) language option for authentic South Asian social media copy.
Added the WhatsApp Broadcast Message content type with structured formatting for direct ordering.
Added visual warnings whenever a draft omits or alters an offer.

Prize Categories

Primary Track: Hacktoberfest Open-Source AI Challenge — Week 2: Side Hustle
Partner / Sponsor Categories:
- Open-Source AI Innovation (Local-first inference with open weights)
- Practical Small Business Enablement

Built with ❤️ during Hacktoberfest 2026.

IRL Quest — AI That Gives You a Reason to Put Your Phone Down 🌿

Anirudha Basu Thakur — Sun, 11 Oct 2026 05:14:31 +0000

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

IRL Quest 🌿

AI that gives you a reason to put your phone down.

Built for the Hacktoberfest Open-Source AI Challenge — Week 1: Touch Grass.

What I Built

Most modern consumer applications are designed to maximize digital engagement: longer sessions, deeper scroll depth, and habitual screen time. Conversational AI can fall into the same pattern, encouraging endless back-and-forth interactions.

IRL Quest turns that paradigm upside down.

The successful user spends less time using the application, not more.

Traditional AI Apps:
User → Prompt → Endless Chat & Scroll → More Screen Time

IRL Quest:
User → Preferences → Local AI Generation
      → Put Phone Down → Explore the Real World
      → Return → Brief Reflection

The Inverted Engagement Loop

Choose Preferences: Select a category (Nature, Exploration, Observation, Mindfulness, or Surprise), a duration (5, 10, 20, or 30 minutes), and a difficulty level.
Local AI Generation: An open-weight instruct model running through LM Studio generates a real-world mission.
Deterministic Safety Filtering: A programmatic regex-based filter checks generated quest content for known hazards, including trespassing, traffic, poisonous plants, dangerous climbing, and unsafe encounters.
Touch Grass Mode: The interface switches to a distraction-free screen with a countdown timer and one message: PUT YOUR PHONE AWAY. GO EXPLORE.
Real-World Discovery: The user puts the phone away and engages with their surroundings.
Procedural Meditation Bell: A harmonic chime synthesized using the Web Audio API signals the end of the quest.
Private Journaling: The user returns, writes a short reflection, and saves it to a browser-based journal with JSON export.

The goal is simple: use AI to facilitate real-world experiences rather than keeping people glued to a screen.

Demo

Application walkthrough

Cover banner

1. Quest Configurator (/)

Configure quest preferences and check the local model connection.

2. Touch Grass Mode (/active)

A distraction-free interface with a countdown and the instruction to put the phone away.

3. Completion & Reflection (/complete)

Capture sensory observations and reflect on the experience.

4. Local Journal & Statistics (/journal)

Review completed quests, track time spent outdoors, and export journal data.

Real-world field testing

The project includes documentation of outdoor tests in docs/FIELD_TESTS.md, covering an urban sidewalk, a public park, and a domestic balcony.

Note: Screenshots and test documentation supplement a demo; if you have a working deployed demo or video walkthrough, add its direct link here.

Code

GitHub repository: https://github.com/Ani0811/irl-quest
License: MIT
Technology: Next.js, React, TypeScript, Tailwind CSS, LM Studio, and open-weight language models.
Local inference: Compatible models include google/gemma-3-4b and Meta-Llama-3.1-8B-Instruct, subject to availability in your LM Studio setup.

The source code and project documentation are available in the repository.

How I Built It

IRL Quest is designed as a local-first web application, emphasizing user control, minimal distractions, and reduced dependence on cloud services.

Architecture

flowchart TD
    User["User"] --> UI["Next.js / React Frontend"]
    UI --> Setup["Quest Setup"]
    Setup --> API["Next.js API Route"]
    API --> Schema["Zod Validation"]
    Schema --> Safety["Deterministic Safety Filter"]
    Safety --> Provider["AI Provider Abstraction"]
    Provider --> LM["LM Studio Local Server"]
    LM --> Model["Open-Weight Language Model"]
    Model --> Safety
    Safety --> Active["Touch Grass Mode"]
    Active --> Complete["Reflection"]
    Complete --> Journal["Local Journal"]
    Journal --> Storage[("Browser Storage")]

Technical highlights

Next.js App Router and TypeScript: Modular routes separate the interface from quest-generation logic.
Model-agnostic AI provider: A standardized AIProvider interface communicates with LM Studio through its local OpenAI-compatible API.
Deterministic safety filtering: Regex and keyword checks inspect generated quest fields for known risk categories, including trespassing, traffic, hazardous plants, wildlife contact, dangerous heights, and unsafe encounters. This is a risk-reduction measure, not a guarantee of safety.
Epoch-based countdown: The remaining duration is calculated using Math.max(0, targetEndTimestamp - Date.now()), helping the timer recover from backgrounding and screen-lock interruptions.
Procedural Web Audio: The completion chime is synthesized using harmonic sine waves and an exponential decay envelope instead of a bundled audio file.
Automated tests: The project includes a Vitest suite for safety filters, JSON sanitization, schema validation, offline catalogs, and journal statistics.

Running locally

git clone https://github.com/Ani0811/irl-quest.git
cd irl-quest
npm install

Start LM Studio, load a supported model, and enable its local server on port 1234. Then run:

npm run dev

Open http://localhost:3000 and configure a quest.

Exact setup requirements may depend on your local environment and the model you choose.

Why Does Open Innovation Matter?

Open innovation makes it possible to experiment with AI in ways that prioritize user autonomy rather than maximizing engagement.

1. Privacy and user control

Real-world habits and personal reflections can be sensitive. A local-first design can keep journal data in browser storage and use local inference, reducing the need to transmit that information to third-party services.

2. Offline independence

Cloud-based AI requires network connectivity. Running inference locally can make quest generation available without an internet connection, provided the application, model, and required assets are already available on the device.

3. Accessibility for independent developers

Open-weight models give developers more control over experimentation and deployment. Local inference can also avoid per-request API charges, although hardware, electricity, and setup still have costs.

4. Model flexibility

A model-agnostic provider abstraction makes it easier to experiment with different compatible models without redesigning the entire application.

5. A different definition of success

IRL Quest challenges the assumption that successful technology must maximize time spent inside an app. Here, success means helping someone leave the interface and engage with the world around them.

Open innovation makes this kind of experimentation more accessible to independent developers and the wider community.

My Agent Session

This project was developed with AI-assisted programming support using Google's Antigravity, including assistance with implementation, testing, and debugging.

Prize Categories

Best Use of Gemma

IRL Quest supports Google's open-weight Gemma model through LM Studio for locally generating real-world quests. This allows users to generate personalized offline activities using local inference rather than relying on a cloud-hosted AI API.

The project combines open-weight AI with a local-first architecture to encourage real-world exploration while reducing dependence on external AI services.

Thank you to DEV, MLH, Google, and the Hacktoberfest 2026 team for championing open AI innovation!

Unsaid: A 100% Local-First AI Reflection Room I Built for a Friend

Anirudha Basu Thakur — Sun, 04 Oct 2026 14:59:55 +0000

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

What I Built

We all have moments where our thoughts run faster than our ability to speak them.

I built Unsaid for a close friend who struggles with severe ADHD, racing thoughts, and chronic late-night overthinking. When overwhelmed, their brain gets trapped in intense cognitive loops—thoughts so tangled and raw that trying to articulate them to another human feels impossible or terrifying. They worry about burdening people, being misunderstood, or facing judgment.

At the same time, they are fiercely guarded about their personal privacy. They refuse to use mainstream cloud AI tools or therapy chatbots because the thought of typing their deepest anxieties and personal confessions into a remote server owned by a corporation that logs prompts, trains models, or risks data leaks felt like a complete non-starter.

Unsaid is a 100% local-first AI reflection room and conversational sounding board. It gives them a safe, distraction-free sanctuary to speak or type freely, untangle racing thoughts, and receive empathetic cognitive reframing without a single byte of data leaving their machine.

Key Capabilities

🎙️ Voice-First Dictation via Handy: Powered by local whisper.cpp, allowing them to speak freely without looking at a screen when typing feels like too much friction.
🧠 Local Cognitive Reframing with Google Gemma 3 4B: Connects to open weights running on local LM Studio or Ollama with zero external telemetry.
🎧 Auditory Reflection Companion: Integration for soothing, human-like voice responses (supporting both local speech synthesis and ElevenLabs voice companion audio).
💻 Bilingual Interface (Web & Monospace Terminal): A sleek glassmorphic web interface, plus an interactive terminal CLI shell for when they want to decompress inside their coding environment.
🔒 Absolute Zero-Cloud Privacy: Everything stays in local memory/IndexedDB, with client-side export and an emergency "Burn Session" button that securely purges all data in one click.

Demo

🌐 Live Web Application: ani0811.github.io/unsaid
📖 Documentation & Interactive Manual: ani0811.github.io/unsaid/website/index.html

Visual Walkthrough & Screenshots

The Reflection Room (Calm, Minimal, Distraction-Free)

Empathetic Conversational Sounding Board

Local Model & Voice Dictation Configuration

Terminal Companion for Developers

Mobile Responsive Experience

Code

Unsaid is fully open source under the permissive MIT License:

🔗 GitHub Repository: https://github.com/Ani0811/unsaid

Clone and run locally in seconds:

git clone https://github.com/Ani0811/unsaid.git
cd unsaid
npm install
npm run dev

How I Built It

Unsaid was engineered from the ground up as a pure offline-capable, local-first stack:

[ Friend's Voice / Thoughts ]
              │
              ▼
[ Local Whisper Engine via Handy ]
              │
              ▼
[ Unsaid Desktop UI (React 19 + TypeScript + Vite) ]
              │
              ├── Local OpenAI-compatible API ──► [ LM Studio / Ollama ]
              │                                           │
              │                                           ▼
              │                                  [ Google Gemma 3 4B ]
              │                                  (Local weights inference)
              │
              ├── Audio Synthesis ──────────────► [ ElevenLabs Companion ]
              │
              └── Dual Local Storage ───────────► [ IndexedDB / ~/.unsaid ]
                                                  (Zero telemetry / Zero cloud)

1. Open AI Brain: Google Gemma 3 4B on LM Studio

For the conversational engine, I chose Google's Gemma 3 4B open-weight model running locally through LM Studio (http://localhost:1234/v1).

Why Gemma 3 4B?: It strikes the perfect balance between nuanced emotional empathy, cognitive reasoning, and local hardware feasibility. It runs smoothly on a consumer laptop with 8GB RAM without overheating the machine or draining battery life.
Empathetic System Prompting: Gemma 3 was tuned to act not as an advice dispenser or generic corporate assistant, but as an active listener using non-violent communication (NVC) and cognitive reframing techniques: asking clarifying questions, reflecting feelings, and helping identify cognitive distortions without being patronizing.

2. Speech Dictation: Handy (Whisper.cpp Engine)

Typing when experiencing cognitive overload can feel exhausting. We integrated Handy, a blazing-fast local speech-to-text dictation tool powered by whisper.cpp. The user holds a hotkey or clicks the microphone, speaks in stream-of-consciousness, and their raw thoughts are transcribed into the reflection prompt in real time.

3. Voice Companion Audio: ElevenLabs & Speech Synthesis

Reading dense paragraphs of text can induce additional eye fatigue when someone is already stressed. Unsaid includes an auditory reflection mode that speaks thoughts back in a soothing, natural cadence, integrating ElevenLabs' natural conversational voices alongside browser-native speech synthesis.

4. Modern Web UI & Terminal Shell

Frontend Stack: Built with React 19, TypeScript, Vite, and Tailwind CSS.
Aesthetic: Deep dark slate themes, subtle glassmorphic blurs, and calm neutral accents designed to reduce sensory stimulation.
Terminal CLI Mode: A retro monospace terminal view accessible directly in the browser or via npm run shell for developers who feel more at home in a command line prompt.

Why Does Open Innovation Matter?

Open innovation and open-weight models weren't just a technical choice for this project—they were the only reason this project could exist at all.

Here is why open models matter so profoundly when building for human vulnerability:

1. Privacy is Emotional Safety

When someone shares their most fragile, unvarnished thoughts—anxieties they are afraid to tell even their closest friends—they cannot and should not trust a third-party cloud API. Closed APIs log requests, store telemetry for trust & safety audits, and operate on remote servers. With open-weight models like Gemma 3, inference happens strictly inside local RAM. The physical wire can be unplugged. The Wi-Fi can be off. The thoughts never leave the room.

2. Independence from Corporate Censorship & Canned Responses

Closed commercial models frequently suffer from "helpful assistant" syndrome: when you express genuine anguish, they often trigger rigid safety filters or spew boilerplate corporate disclaimers that make the person feel alienated and treated like a ticket. Open weights allow builders to craft custom emotional guardrails and genuine warmth tailored to what their friend actually needs to hear.

3. Zero Cost Barrier

A friend in distress shouldn't have to worry about whether they have enough API credits left on their credit card or whether a monthly subscription will renew. Open-source models run forever for free on existing hardware.

What My Friend Said When I Handed It Over

"The hardest part of having ADHD for me isn't focusing on work—it's the silence late at night when ten different threads of anxiety start fighting for attention. I always wanted to journal, but typing into an empty Google Doc made me feel exposed, and talking to ChatGPT felt like talking to a surveillance camera with a customer service voice.

Unsaid is the first time I felt like I had a door I could shut behind me. Being able to just hit the mic, ramble about why I felt stuck, and have Gemma reflect it back to me calmly—without anything touching the internet—let me breathe again. It's on my desktop now."

My Agent Session

This project was built with the assistance of an agentic workflow through DevRelay. You can explore the full interactive transcript:

🔗 View the DevRelay Agent Session Transcript (#457)

Prize Categories

🏆 Best Use of Gemma ($200 Featured Category): Deep integration of Google's Gemma 3 4B open weights via LM Studio/Ollama as the local cognitive reflection engine.
🎙️ Best Use of ElevenLabs ($100 Partner Category): Conversational auditory companion mode using high-fidelity human-like voice reflection.
🌟 Overall Winner ($250): A complete, lovingly crafted solution tackling a real human problem with 100% open-source AI, zero cloud dependencies, and full open-source delivery.

Thank you to DEV, MLH, Google, and the Hacktoberfest 2026 team for championing open AI innovation!