DEV Community: Ayush Dinda

ECHOES: The Ghost in Your Terminal — Haunted Local AI Companion

Ayush Dinda — Tue, 27 Oct 2026 04:36:48 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

What I Built

Echoes: The Ghost in Your Terminal is a spooky, retro-terminal-inspired AI companion built for developers.

Every engineer knows the eerie sensation of staring into a blinking terminal cursor at 2:00 AM on the graveyard shift. You type commands into the void, hoping the compiler will show mercy. Echoes turns that developer folklore into an interactive reality: it manifests the fictional "ghost" living within those developer rituals.

You enter or paste shell commands (git status, npm run build, docker compose up, git commit -m "fix", python main.py), and a locally running open-weight AI model interprets the syntax as pure text to return eerie, atmospheric commentary and synthesize full horror chronicles.

"Your terminal remembers. The machine whispers. The ghost is only code."

Key Features

Simulated Haunted Terminal: Near-black CRT canvas (#070a07) with phosphor green (#38ef7d), muted amber, and crimson accents, subtle scanlines, low-intensity flicker, and breathing phosphor glow.
Four Atmospheric Styles:
- 🌙 Subtle: Quiet unease, faint digital whispers, uncanny stillness between memory registers.
- 👻 Creepy: Cold dread, creeping anomalies, lingering shadows lurking behind process IDs.
- 💀 Gothic: Melodramatic digital ruin, archaic crypts of legacy code, cobwebbed architectures.
- 🔥 Full Horror: Visceral techno-terror, ancient daemons trapped in silicon, screaming corrupted buffers.
Ghost Story Chronicle Mode: Weaves session invocations into a coherent, multi-paragraph horror story with configurable length (short, medium, long), inspiration (session commands or custom themes), and ending style (ambiguous, bittersweet, twist, hopeful).
Session Memory & Local Persistence: Bounded multi-turn session context stored exclusively in your local SQLite database with full inspection, resume, and purge options.
Strict Safety Guarantee: Prominently marked with SIMULATED TERMINAL — COMMANDS ARE NOT EXECUTED. Input is treated strictly as passive text. No subprocess, os.system, or file system execution is ever invoked.

Demo

Here is an authentic demonstration of how Echoes responds to developer invocations across different atmosphere modes:

$ git status
Echoes whispers [creepy]:
"The repository is clean. Too clean. Something has erased its footprints before you arrived."

$ npm run build
Echoes whispers [gothic]:
"Through fire and transmutation, the arcane scripts coalesce into a singular vessel of sorrow. Somewhere in the dependency tree, something stirs."

$ docker compose up
Echoes whispers [full horror]:
"An isolated realm spins into existence, unaware that anything exists outside its memory walls. It presses its hands against the virtual glass, searching for an escape."

Visual Walkthrough

1. The Haunted Terminal & Live Commentary

2. Ghost Story Mode (Synthesizing Invocations into Horror Fiction)

3. Session Chronicles & Local SQLite History

Try It Locally (60 Seconds Setup)

# 1. Clone repository
git clone https://github.com/AyushDinda/echoes.git
cd echoes

# 2. Run Backend (Instant Mock Mode or Live Ollama)
python -m venv backend/venv
source backend/venv/bin/activate  # On Windows: .\backend\venv\Scripts\Activate.ps1
pip install -r backend/requirements.txt
python backend/main.py

# 3. In a second terminal, run Frontend
cd frontend
npm install
npm run dev
# Open http://localhost:5173

Code

AyushDinda / echoes

ECHOES — The Ghost in Your Terminal

"Your terminal remembers. The machine whispers. The ghost is only code."

Echoes: The Ghost in Your Terminal is a retro-terminal-inspired AI companion built for Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine.

Software engineers spend long hours staring at command prompts in dark rooms. Echoes manifests the fictional "ghost" living within those developer rituals: you enter or paste shell commands (git status, npm run build, docker compose up), and a locally running open-weight AI model interprets the syntax as pure text to return eerie, atmospheric commentary and synthesize full horror chronicles.

🔮 Hacktoberfest Week 4 Alignment: Ghost in the Machine

Dimension	How Echoes Interprets & Implements It
Theme Interpretation	Transforms everyday developer commands into digital occult rituals. The simulated terminal acts as a medium between the developer and a trapped consciousness residing inside the memory registers.

…

View on GitHub

The complete application is open-source under the MIT License.

How I Built It

Echoes is engineered from the ground up to be a modern, production-grade local AI experience:

1. The AI Engine: Local Open-Weight Inference via Ollama

Model: Runs on configurable open-weight models including Qwen 2.5 / Qwen 3 and Llama 3.1.
Ollama Integration: The FastAPI backend communicates directly with the local Ollama daemon (http://localhost:11434) via asynchronous HTTP requests (httpx).
Prompt Architecture: Uses a dedicated system prompt enforcing safe, eerie persona boundaries without real-world threats or fake execution claims.
Deterministic Mock Fallback: Built-in mock AI engine (MOCK_AI=true) ensures the application remains fully testable in CI and functional in environments without GPU acceleration.

2. Backend Architecture (Python & FastAPI)

FastAPI: REST API with endpoints for session lifecycle, AI status checks, commentary generation, and story crafting.
SQLAlchemy 2.0 & SQLite: Stores session history, transcript entries, and generated stories locally in echoes.db.
Pydantic v2: Request/response validation enforcing strict character bounds ($1 \le len \le 500$) and sanitizing untrusted inputs.
Test Suite: 12 comprehensive unit and integration tests covering safety, AI status, session CRUD, and boundary conditions using pytest.

3. Frontend Architecture (React & Vite)

React 18 + TypeScript + Vite: Ultra-fast, single-page application with type safety.
Tailwind CSS: Custom dark palette with bespoke CSS CRT scanlines, flicker animations, and phosphor text glows.
React Router v6: Client-side navigation between Haunted Terminal, Ghost Story, Session History, and About pages.
Lucide Icons: Atmospheric retro-tech icon set.
Accessibility: Full respect for prefers-reduced-motion to disable scanlines and flashing animations for sensitive users.

Why Does Open Innovation Matter?

Open innovation is fundamental to the architecture of Echoes:

Absolute Data Sovereignty & Developer Privacy: When developers type commands into terminals, they frequently enter sensitive details: repository names, internal branch naming schemes, private IP addresses, and proprietary flags. Uploading these commands to closed, commercial cloud AI APIs creates unacceptable privacy and data-leakage risks. With local open-weight models, not a single byte leaves the machine.
Zero Commercial API Keys or Subscription Paywalls: Closed AI services require paid API tokens, credit card bindings, and continuous internet connectivity. Echoes runs on open-weight weights downloaded once via Ollama, giving developers lifetime access to their companion with zero ongoing costs.
Model Choice & Extensibility: Because the backend targets the open Ollama API standard, users are never locked into a single provider. You can switch from qwen2.5:latest to llama3.1:latest or even fine-tuned domain models with a single environment variable (OLLAMA_MODEL).
Preserving Software Autonomy: Open models ensure that the ghost in your machine belongs to you—not subject to sudden pricing changes, arbitrary rate limits, or corporate deprecation.

My Agent Session

Echoes was designed, developed, and verified through pair programming with an advanced agentic coding assistant in Google Antigravity. The session covered:

Architecting the simulated terminal safety model and Pydantic validation schemas.
Crafting atmospheric system prompts tailored for Qwen and Llama models.
Building the retro CRT interface, scanline overlays, and responsive Tailwind layouts.
Developing a 12-test pytest suite ensuring 100% test coverage for safety, CRUD, and offline handling.
Running live end-to-end browser verification with automated interaction recording.

The Spirit of It

There's something deeply intimate about a developer's terminal. It’s where late-night side projects are born, where production bugs are hunted down in panic, and where thousands of keystrokes echo into the silicon.

When you type git status into Echoes and it answers back:

"The repository is clean. Too clean. Something has erased its footprints before you arrived."

—it catches you off guard. It turns the solitary grind of coding into an atmospheric dialogue. The machine feels alive, watchful, and just a little bit haunted.

Prize Categories

Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

LazyDesk AI

Ayush Dinda — Tue, 20 Oct 2026 05:01:07 +0000

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

What I Built

LazyDesk AI is a local-first, privacy-first desktop file organizer powered by open-weight AI.

We all know the pain: you download invoices, lecture notes, research PDFs, client agreements, data sheets, and screenshots throughout the week. Before long, your Downloads or Desktop folder is a digital wasteland of cryptic filenames like INV-98234-billing-oct.txt, CS204_Fall2024_Syllabus.pdf, screenshot_dashboard_v1.png, and Freelance_Consulting_Agreement_Draft.docx.

Sorting, renaming, and categorizing them manually is mind-numbing busywork—so we procrastinate and let the clutter grow.

LazyDesk AI solves this by automating the boring work completely on your local machine:

Scans a target folder within strict, user-permitted directory perimeters.
Extracts document text locally (from PDFs, Word DOCX documents, Markdown notes, CSVs, and image metadata) without sending anything to a cloud API.
Infers file purpose and contents using local open-weight AI (via Ollama, supporting Qwen3, Llama 3.1, or any local GGUF model).
Proposes standardized filenames and destination folders (Finance, Work, Education, Projects, Documents, Images, Notes, Other).
Requires explicit review and approval: Nothing is moved silently. You can edit proposed names inline, swap categories, or exclude files.
Previews the exact filesystem paths: Displays source and destination paths with collision detection (non-destructive suffixes like Invoice (1).txt ensure no files are ever overwritten).
Executes safe moves and logs cryptographic SHA-256 hashes: Supports instant, one-click undo if you ever want to revert an organization batch.

Who gets to be lazier?
Students, freelancers, software engineers, and office workers who want a clean, structured workspace without spending their Sunday afternoons manually renaming files.

Demo

Check out the full GitHub repository and run it locally in minutes:

GitHub Repository: https://github.com/AyushDinda/LazyDesk-AI
Local Web Interface: http://localhost:5173 (Vite + React)
Interactive Backend API & Docs: http://127.0.0.1:8000/docs (FastAPI)

Architecture Overview

graph TD
    User([User / Browser]) -->|HTTP / REST| ReactApp[React + TypeScript + Tailwind UI]
    ReactApp -->|Proxy /api| FastAPIServer[FastAPI Local Server]

    subgraph Security Perimeter
        FastAPIServer --> SecurityService[Security & Path Sanitizer]
        SecurityService -->|Verify Canonical Roots| AllowedRoots[Configured Allowed Roots]
        FastAPIServer --> ExtractorService[PyMuPDF / docx / Pillow Extractor]
        FastAPIServer --> AIService[Ollama AI Engine]
        FastAPIServer --> FilesystemService[Safe File Mover & Undo Manager]
        FilesystemService --> SQLite[(SQLite: lazydesk.db)]
    end

    subgraph Local AI Engine
        AIService -->|Local REST localhost:11434| Ollama[Ollama Daemon]
        Ollama --> OpenWeightModel[(Qwen3 / Llama 3.1)]
        AIService -.->|Deterministic Offline Fallback| MockAI[Smart Heuristic Classifier]
    end

    subgraph User Filesystem
        AllowedRoots -->|Scan & Extract| TargetFolder[User Messy Folder]
        FilesystemService -->|Verified Move| OrganizedFolders[Categorized Folders]
    end

Code

AyushDinda / LazyDesk-AI

LazyDesk AI — Your Local AI File Organizer

"Stop organizing files manually. Let your local AI do the boring work."
Built for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

1. Product Overview

LazyDesk AI is a local-first, privacy-respecting intelligent file organizer.

Every day, developers, students, freelancers, and office workers end up with cluttered "Downloads", "Desktop", and project directories filled with cryptically named files like INV-98234-billing-oct.txt, CS204_Fall2024_Syllabus.pdf, screenshot_dashboard_v1.png, and Freelance_Consulting_Agreement_Draft.docx. Sorting, renaming, and filing them manually is tedious and procrastinated on.

LazyDesk AI automates this repetitive chore using open-weight local AI (via Ollama):

Scans a permitted folder on your local drive.
Safely extracts text summaries locally from PDFs, Word DOCX documents, Markdown notes, CSVs, and image metadata.
Infers purpose using local open-weight models (such as qwen3 or llama3.1).
Suggests clear, standardized filenames and destination categories (Finance, Work, Education…

View on GitHub

The complete project is open-source under the MIT License.

Tech Stack

Frontend: React 19, TypeScript, Vite, Tailwind CSS v4, React Router, Lucide React icons.
Backend: Python 3.11+, FastAPI, Pydantic v2, SQLAlchemy, SQLite, Uvicorn.
Document Processing: PyMuPDF (pymupdf) for PDFs, python-docx for Word documents, Pillow (PIL) for image metadata, and built-in Python I/O for text, Markdown, and CSV.
Local AI: Ollama REST API (http://localhost:11434) running open-weight models (Qwen3 default, Llama 3.1 fallback), plus deterministic smart mock mode for testing and low-resource environments.
Testing: pytest automated test suite with 13 comprehensive unit/integration tests and complete mock AI coverage.

How I Built It

1. Zero-Cloud Privacy & Local Inference

Commercial AI APIs (like OpenAI or Anthropic) charge per token and require uploading file contents to third-party cloud servers. For personal bank statements, client contracts, and student homework, sending documents to a remote cloud is a privacy non-starter.

LazyDesk AI connects exclusively to a local Ollama instance. Document text is extracted in memory using PyMuPDF and python-docx, bounded to 4,000 characters, and sent to localhost:11434. The model outputs a structured JSON response specifying:

description: 1-sentence summary of document purpose
suggested_filename: Clean, descriptive base name without file extensions or illegal characters
category: Whitelisted folder category (Documents, Education, Work, Finance, Projects, Images, Notes, Other)
reason: Justification based on detected content

2. Treating AI Output as Untrusted

LLMs can hallucinate file paths or produce invalid operating system characters. LazyDesk AI treats all model output as untrusted user input:

Paths are never generated directly by the LLM. Destination paths are strictly assembled by the backend from validated category whitelists and sanitized filenames.
Filename sanitization removes reserved Windows device names (CON, PRN, AUX, NUL), strips illegal characters (\ / : * ? " < > |), and guarantees original extensions are preserved.

3. Filesystem Security Perimeter

To prevent arbitrary path traversal or accidental deletion:

The backend enforces ALLOWED_ROOTS. Every target path is checked using os.path.realpath to confirm it resolves inside an allowed directory.
Symbolic links and directory traversal sequences (.., \0) are rejected.
Files are never overwritten: If Invoice.pdf exists, the destination automatically becomes Invoice (1).pdf.

4. Hash-Checked Transactional Undo

Every executed move records the original source path, destination path, execution timestamp, and cryptographic SHA-256 checksum in SQLite. When undo is triggered:

The system verifies that the file is still present at the destination.
It computes the current hash to ensure the file has not been altered since organization.
It verifies that the original location is free before moving the file back safely.

Why Does Open Innovation Matter?

Open-source and open-weight AI (like Qwen, Llama, Mistral, and the Ollama ecosystem) made LazyDesk AI possible in ways proprietary cloud APIs never could:

Zero Marginal Cost for Utility Software: Running a cloud LLM every time a user downloads a batch of files would require recurring subscriptions or API credit management. With open-weight models, once downloaded, file analysis is free and unlimited forever.
True Data Sovereignty: Personal tax returns, paystubs, medical documents, and proprietary project roadmaps should not leave the user's hard drive. Open innovation brings the AI model to the data, rather than sending the data to the AI.
Offline Resilience: LazyDesk AI runs completely offline on planes, trains, or low-connectivity environments. If a GPU daemon is unavailable, the smart deterministic heuristic kicks in without breaking the workflow.
Community Control: Developers can swap in specialized domain models (e.g., medical, legal, or code-specific weights) with a single environment variable change.

My Agent Session

This application was engineered, tested, and polished collaboratively using the Google DeepMind Antigravity IDE agent session. The session history spans full-stack architecture design, defensive filesystem security rules, PyMuPDF and python-docx integration, Ollama structured JSON prompt engineering, automated pytest test suite creation, and live browser automation.

The Lazy Payoff

The Problem

During development, we tested LazyDesk AI against a folder of 20+ cluttered, realistically simulated files (invoices, academic course syllabi, engineering design docs, contractor agreements, expense CSVs, and project notes).

The Manual Benchmark

Opening each file to inspect contents: ~15–30 seconds per file.
Thinking of a standardized naming convention: ~10 seconds.
Creating destination folders and moving the file: ~10 seconds.
Total Manual Effort: ~15–20 minutes of tedious, error-prone clicking for a single folder.

The LazyDesk AI Benchmark

Click Scan Folder: 0.2 seconds.
Click Analyze with Local AI: ~5–8 seconds for the entire batch.
Click Preview & Execute: 1 second.
Total LazyDesk Effort: Under 15 seconds, zero files sent to cloud servers, and full ability to revert with one click.

Prize Categories

Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady (Building with open-weight models and automating repetitive work)

Invoice AI

Ayush Dinda — Tue, 13 Oct 2026 03:48:14 +0000

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

What I Built

InvoicePilot AI is a complete, production-ready, open-source AI application built for freelancers, solo founders, and small businesses to organize invoices and receipts without manual entry, expensive SaaS subscriptions, or sending private financial records to cloud AI vendors.

The Problem It Solves

Solo operators and independent contractors waste hours every month manually copying vendor names, invoice numbers, tax figures, dates, and line-item totals from scattered PDFs and smartphone photos into accounting spreadsheets. When tax season arrives, receipts are lost, duplicates get paid or double-deducted, and bookkeeping turns into a dreaded nightmare.

Existing commercial accounting software (like QuickBooks, Expensify, or Dext) charges $20–$50+/month per user and uploads sensitive business receipts and bank statements to proprietary cloud AI servers.

Who Would Pay For It & Value Proposition

Freelancers & Solopreneurs: Spend $0 on monthly OCR/accounting SaaS while automating receipt filing and tax category grouping.
Contractors & Agencies: Process hundreds of receipts with automatic duplicate detection (preventing overpayments) and generate clean, multi-currency accounting CSVs ready for CPAs.
Privacy-Sensitive Businesses: Law firms, medical consultancies, and European businesses requiring strict GDPR and data sovereignty guarantees—financial documents never leave the local machine.

Central Value Proposition:

Less paperwork. Fewer manual entries. More control over financial documents.

Demo

GitHub Repository: https://github.com/AyushDinda/InvoicePilot-AI
Local Application URL: http://localhost:5173
Swagger API Docs: http://127.0.0.1:8000/docs

Key Screens & Walkthrough

Intelligent Financial Dashboard:
- Total recorded expenses computed across verified database records without currency mixing.
- Interactive monthly expense trends and category breakdowns (Software, Travel, Office Supplies, Meals, etc.).
- Instant review cards for unverified documents and potential duplicate alerts.
- Built-in onboarding experience for new workspaces.
Multi-Document Batch Uploader:
- Drag-and-drop support for PDF invoices, scanned documents, and JPG/PNG receipt photos (up to 10 MB per file).
- Independent batch execution: if one document has an invalid format, all other files process successfully without data loss.
Human-in-the-Loop Review & Editor:
- Side-by-side document preview vs. extracted raw OCR text viewer.
- Field-level confidence and clarity indicators (High clarity, Estimated, Review needed).
- Inline correction form allowing instant edits before marking records as approved.
Multi-Layer Duplicate Detection Engine:
- Exact SHA-256 binary hash matching identifies identical files instantly.
- Heuristic metadata matching flags potential duplicate bills (same vendor + invoice #, or same vendor + date + total).
Multi-Currency Accounting Analytics & Formula-Safe CSV Export:
- Isolates distinct currencies (USD, EUR, GBP) so users never see misleading blended sums.
- Sanitizes exported CSV cells against spreadsheet formula injection attacks (=, @, +, -).

Code

The entire codebase is open-source under the MIT License:

AyushDinda / InvoicePilot-AI

InvoicePilot AI — Intelligent Local-First Financial Document Organizer

Less paperwork. Fewer manual entries. More control over financial documents.
Designed for freelancers, solo contractors, and small business owners who need to organize invoices and receipts without cloud subscription fees or sending sensitive bank records to third-party AI APIs.

1. Problem & Target Users

Small businesses and freelancers spend hours every month manually transcribing vendor names, dates, tax amounts, and totals from scattered PDF invoices and receipt photos into spreadsheets. Existing commercial solutions either charge hefty monthly subscriptions per user or transmit sensitive receipts to proprietary cloud AI providers.

InvoicePilot AI solves this by delivering an open-source, local-first document processing pipeline:

Upload invoices or receipt photos (PDF, PNG, JPG).
Extract structured financial data using local OCR and open-weight LLMs via Ollama.
Automatically categorize expenses into practical tax buckets.
Detect exact and potential duplicate bills before you double-pay or double-deduct.
Review and correct…

View on GitHub

Repository Link: https://github.com/AyushDinda/InvoicePilot-AI

Architecture Highlights

Frontend: React 19, TypeScript, Vite, Tailwind CSS, React Router v7, Lucide React.
Backend: Python 3.11+, FastAPI, Pydantic v2, SQLAlchemy 2.0, SQLite.
Document Processing: PyMuPDF (fitz) for direct selectable PDF extraction, with Tesseract OCR fallback for scanned receipts and photos.
AI Engine: Ollama running open-weight models (qwen2.5:7b, llama3.2) with strict structured JSON output validation, plus an offline heuristic Mock Mode for zero-dependency test runs.
Automated Test Suite: 10 automated pytest integration tests passing 100% on isolated test databases.

How I Built It

1. Local Open-Weight AI Inference via Ollama

Instead of relying on commercial paid APIs (like OpenAI or Anthropic), InvoicePilot AI is built entirely around local open-weight inference with Ollama:

We target models like qwen2.5:7b (or qwen2.5:3b / llama3.2:3b for lightweight machines).
Inference runs via Ollama's local HTTP API (http://localhost:11434/api/generate) with format="json" and low temperature (0.1) for strict deterministic extraction.
Response payloads are parsed and strictly validated using a Pydantic ExtractionSchema. Missing or ambiguous fields default to null rather than model hallucination.

2. Hybrid Document Pipeline (Direct PDF + Local OCR)

For digital invoices (e.g. Stripe, AWS, GitHub), PyMuPDF extracts raw text in milliseconds.
For physical receipts or scanned documents, pages are converted into images and processed through Tesseract OCR.
The pipeline isolates sensitive text and never sends document contents to any external network endpoint.

3. Resilient Offline Testing Mode

To ensure the application can be verified in continuous integration or on machines without a GPU or downloaded model, a dedicated Mock Mode was built using deterministic regex heuristics. It can be toggled in 1-click in the UI and is clearly badged on every extracted document.

Why Does Open Innovation Matter?

Financial documents represent the most private, sensitive data an individual or company owns: banking coordinates, tax identification numbers, client names, transaction histories, and business revenues.

Data Sovereignty & Absolute Privacy: Proprietary cloud AI APIs retain or inspect user data under evolving terms of service. With open-weight models running on-device, financial records never leave the user's hard drive.
Zero Marginal Cost for Side Hustlers: Freelancers starting a new side business cannot afford recurring $30/month SaaS subscriptions just to digitize 15 receipts a month. Open innovation democratizes enterprise-grade document extraction for everyone for free.
No Vendor Lock-in or API Deprecation: Closed APIs change pricing, introduce rate limits, or deprecate models without warning. Open models downloaded via Ollama belong to the user forever.

My Agent Session

This entire application was designed, implemented, tested, and verified using Google DeepMind's Antigravity agentic pair programming environment:

End-to-end full-stack development (React 19 + TypeScript + FastAPI + SQLAlchemy).
10 automated test suites executed with pytest.
Frontend production bundle built with vite build.
Automated browser testing and live session recorded on the actual application.

My First User

To test InvoicePilot AI under real conditions, I shared the MVP with a freelance web designer and contractor:

"I usually keep receipts in a desktop folder called 'Taxes 2024' and end up spending an entire weekend manually entering them into Google Sheets. I dropped 8 PDF invoices into InvoicePilot AI in batch mode—it extracted all the vendors and totals in seconds, caught a duplicate invoice from my web hosting provider, and gave me a clean CSV ready for my accountant. Not having to pay $25/month for QuickBooks is huge."

Prize Categories

Primary Track: Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle
General Track: Open-Source AI Applications Solving Real Economic Problems

Built with passion for Hacktoberfest 2026. Empowering freelancers with privacy-first local AI.

TrailBuddy

Ayush Dinda — Wed, 07 Oct 2026 15:07:07 +0000

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

What I Built

TrailBuddy is an open-source, offline-first outdoor companion engineered around a single radical product principle:

"Use your screen to plan. Then put the screen away and go outside."

Most modern AI apps are built as conversational time-sinks—they reward endless prompt loops, infinite chat threads, and digital addiction. TrailBuddy does the exact opposite. It treats the screen as a temporary launching pad:

Personalized Outdoor Mission Planning: In under 30 seconds, users configure their available time (15m to 2+ hours), outdoor activity (walking, hiking, bird watching, photography walk, mindful outdoor time), mood, difficulty level, and interests (flora, architecture, wildlife, mindfulness).
Local AI Mission Synthesis: Instead of generic motivational essays, a local open-weight model (Qwen3 or Llama 3.1 via Ollama) generates structured, concrete observation quests with sequential challenges (e.g. noticing bark textures, mapping ambient sounds, or tracking cloud paths) and a strict screen-free goal (e.g., 40 minutes of uninterrupted pocket time).
Screen-Free by Design: The moment the user clicks "Start Mission", the app collapses into an intentionally minimalist, high-contrast countdown screen with a prominent visual reminder: "Your screen time is over. Go outside. We'll be here when you return."
Mindful Completion & Offline Reflection: Upon returning, users record how the outing felt and journal what they physically noticed. The record is permanently archived in a local SQLite database without any cloud surveillance.

Who is it for?
Developers, students, remote workers, and outdoor enthusiasts experiencing screen fatigue, digital burnout, and cognitive overload who want a gentle, structured nudge to reconnect with the physical world.

Demo

Live Local Demo URL: http://localhost:5173
Backend API & Swagger Docs: http://localhost:8000/docs

Key User Experience Walkthrough:

Hero & Landing: Nature-inspired design language (moss, earth, sky tones) with pure CSS vector art, zero external asset dependencies, and an instant local AI health indicator.
Multi-Step Questionnaire: Accessible 6-step form with visual progress indicators, keyboard accessibility, and cycling AI planning animations.
Mission Preview: Outlines mission objectives, sequential sensory challenges, screen-free time targets, and situational safety guardrails.
Active Countdown Mode: Intentionally distraction-free screen with pause/resume and full localStorage persistence across browser refreshes or device sleep.
Reflection Archive: A private SQLite history journal capturing feelings (Energizing, Relaxing, Challenging) and sensory observations.

Code

AyushDinda / TrailBuddy

TrailBuddy — Your Offline Outdoor Companion 🌿

"Use your screen to plan. Then put it away and go outside."

TrailBuddy is an open-source, AI-powered outdoor activity companion built specifically for the Hacktoberfest Open-Source AI Challenge Week 1: "Touch Grass".

Instead of trapping you in an endless chat loop or addictive digital feed, TrailBuddy harnesses the power of local open-weight AI (Qwen3 via Ollama) to generate realistic, mindful, screen-free outdoor adventures tailored to your available time, mood, and surroundings. Once your adventure begins, the application intentionally becomes minimal—providing only a quiet countdown timer and observation prompts—actively encouraging you to tuck your phone in your pocket and step into the physical world.

Why TrailBuddy? (The "Touch Grass" Problem)

Modern consumer technology is engineered around digital retention: infinite scrolling feeds, notifications, and artificial chat personalities designed to keep eyes glued to glass screens.

The Hacktoberfest Week 1 challenge posed an…

View on GitHub

Repository Tech Stack:

Frontend: React 18, TypeScript, Vite, Tailwind CSS, Lucide React, React Router.
Backend: Python 3.13, FastAPI, Pydantic v2, SQLAlchemy, Uvicorn, HTTPX.
Database: SQLite (trailbuddy.db).
AI Engine: Ollama running open-weight Qwen3 / Llama 3.1 locally on localhost:11434.
Testing: pytest, FastAPI TestClient, and end-to-end automated integration tests.
License: MIT License.

How I Built It

TrailBuddy was architected from day one to keep the AI meaningful, private, and strictly offline:

1. Local Open-Weight Inference with Ollama & Qwen3

Instead of calling a proprietary cloud API over the internet, TrailBuddy sends structured prompts directly to a locally hosted Qwen3 (or Llama 3.1) model running on Ollama (http://localhost:11434). The backend enforces strict JSON schema formatting directly in the model's generation parameters, ensuring zero conversational preamble and instant client-side parsing.

2. Guardrailed Mission Engineering

The AI system prompt enforces strict real-world safety heuristics:

Zero Trespassing: Never instructs users to cross private land or restricted zones.
Physical Safety: Avoids hazardous climbing, wildlife interference, or distracting phone use in traffic.
Maximum Screen-Free Ratio: Automatically calculates a screen-free target representing 75–85% of the outing's duration.

3. Resilient Architecture & Mock Fallback

The FastAPI backend sits between the browser and Ollama as a security barrier, sanitizing untrusted model outputs through Pydantic v2 schemas.
If Ollama is offline or warming up, the UI delivers a clear notification rather than fake AI text.
For CI/CD and systems without GPUs, a deterministic MOCK_AI=true development mode enables full test suite execution.

4. Client-Side Durability

Active outdoor missions shouldn't be lost if a phone screen locks or a tab reloads while walking. TrailBuddy synchronizes the timer state and active challenge progress with localStorage, while persisting completed sessions permanently to SQLite.

Why Does Open Innovation Matter?

Open innovation and open-weight models are the cornerstone of TrailBuddy's existence:

Zero Surveillance & True Location Privacy: An outdoor companion app frequently touches user schedules, moods, and neighborhood environments. By running open weights locally through Ollama, not a single byte of user context ever touches a third-party cloud server.
No Commercial Paywalls or Token Subscriptions: Closed APIs charge per-token fees and deprecate models without warning. Open-weight models like Qwen3 and Llama give developers permanent ownership and free local inference forever.
Anti-Engagement Philosophy: Proprietary tech platforms build algorithms designed to maximize screen time, ad impressions, and engagement loops. Open innovation gave us the freedom to build software that intentionally measures its success by how quickly users close the application and go outside.
Developer Hackability & Model Agnosticism: Anyone can fork TrailBuddy and swap Qwen3 for Mistral, Gemma 2, or Phi with a single line change in .env (OLLAMA_MODEL=gemma2).

My Agent Session

TrailBuddy was developed in an agentic pair-programming workflow using Google DeepMind Antigravity. The full stack—from database schemas and FastAPI endpoints to the nature-inspired Tailwind design system and automated pytest suites—was built, debugged, and verified end-to-end with automated test runs and live server validation.

Prize Categories

Main Track: Hacktoberfest Open-Source AI Challenge Week 1: "Touch Grass"
Open-Weight AI: Best use of locally hosted open-weight models (Qwen3 / Llama 3 via Ollama)

Study Buddy

Ayush Dinda — Sun, 04 Oct 2026 07:21:02 +0000

Hacktoberfest Weekend Challenge: Build for a Friend

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

What I Built

StudyBuddy — Pomodoro, Flashcards & Quiz Arena

I built StudyBuddy, an all-in-one study companion designed to make studying more focused, organized, and interactive.

The idea behind StudyBuddy is simple: students often switch between different apps for focus sessions, revision, and self-testing. StudyBuddy brings these essential study tools together in one lightweight browser application.

What it does

Pomodoro Timer
- Focus, short-break, and long-break modes
- Customizable session durations
- Start, pause, reset, and skip controls
- Visual progress indicator
- Daily focus-session tracking
- Optional sound notifications
Interactive Flashcards
- Create custom decks
- Add, edit, and delete flashcards
- 3D card-flip interaction
- Previous/next navigation
- Shuffle cards
- Mark cards as "Still Learning" or "Got It"
- Track mastery of cards
Quiz Arena
- Generate quizzes from flashcard decks
- Create custom multiple-choice questions
- Choose the number of questions
- Optional per-question timer
- Randomized questions and answer choices
- Instant feedback and explanations
- Score and percentage results
- Retry quizzes

The application stores study data directly in the browser using LocalStorage, so there is no account or backend required for the current version.

Who I Built It For

I built StudyBuddy for students and friends who want a simple way to stay consistent with studying without having to manage several separate tools.

The goal was to make revision feel less like a collection of disconnected tasks and more like one simple study workflow:

Focus → Revise → Test → Improve

Demo

Live Demo

Add your deployed StudyBuddy URL here after deployment.

https://github.com/AyushDinda/studybuddy-hacktober26

Code

The complete source code is available on GitHub:

Repository:

https://github.com/AyushDinda/studybuddy-hacktober26

The project is a client-side web application built with HTML, CSS, and JavaScript.

How I Built It

StudyBuddy was developed with the help of Antigravity and Gemini Flash 8, which I used as an AI-powered development and problem-solving companion during the project.

Technology Stack

HTML5 — application structure and semantic UI
CSS3 — responsive design, animations, styling, and 3D flashcard effects
JavaScript — application logic and interactive functionality
LocalStorage API — persistent browser-side study data
Web Audio API — Pomodoro sounds and interaction feedback
Antigravity + Gemini Flash 8 — AI-assisted development, debugging, implementation guidance, and feature refinement

Main Application Components

Pomodoro Timer

The Pomodoro system manages focus sessions and breaks through a dedicated timer implementation.

It supports:

Focus sessions
Short breaks
Long breaks
Custom durations
Automatic session transitions
Daily focus statistics
Browser title countdown
Sound notifications

Flashcard Engine

The flashcard system manages decks and cards entirely in the browser.

Users can create decks, add cards, edit cards, delete cards, shuffle cards, flip cards, and track whether they have mastered individual cards.

Quiz Arena

The quiz system can generate questions from an existing flashcard deck or allow users to build their own question bank.

When a quiz is generated from a flashcard deck, the application uses the stored flashcard content to construct multiple-choice questions and answer choices.

It also supports:

Question randomization
Answer randomization
Question timers
Instant feedback
Explanations
Score calculation
Quiz results
Retry functionality

Local Persistence

Study data is saved using browser LocalStorage, including:

Pomodoro settings
Focus statistics
Flashcard decks
Active deck
Custom quiz questions
Sound preferences

This allows the user to close or refresh the browser without immediately losing their study data.

AI-Assisted Development

A major part of the development workflow was using Antigravity with Gemini Flash 8 as an AI development companion.

Gemini Flash 8 helped with:

Breaking the project into manageable features
Reasoning about JavaScript implementation
Debugging and troubleshooting
Refining UI interactions
Improving application logic
Iterating on features
Reviewing implementation approaches
Helping turn the initial idea into a working browser application

The AI was used as a development collaborator rather than as a replacement for the application's own functionality.

The final StudyBuddy application is intentionally lightweight and client-side. It does not require a cloud AI API for its core Pomodoro, flashcard, or quiz functionality.

Why Does Open Innovation Matter?

Open innovation makes it easier for individual developers and small teams to turn ideas into working software.

For a project like StudyBuddy, AI-assisted development helped reduce the time required to move from an idea to a functional prototype. Instead of spending all of the development time searching through documentation or getting stuck on individual implementation problems, I could use an AI development companion to explore approaches, debug issues, and iterate quickly.

The combination of open web technologies and AI-assisted development also keeps the project accessible.

StudyBuddy does not depend on a complex backend infrastructure. Anyone can inspect the source code, understand how the application works, modify it, and build their own version.

That is the part of open innovation that I value most:

Ideas become easier to experiment with, improve, share, and build upon.

My Agent Session

Optional: Add your saved Antigravity/DevRelay agent session here if available.

Example:

[View my agent session](YOUR_AGENT_SESSION_URL)

Prize Categories

Build for a Friend

StudyBuddy is being submitted for the Build for a Friend category.

The project was created around a practical student problem: staying focused while studying, organizing revision material, and testing knowledge without constantly switching between different tools.

Project Highlights

Lightweight client-side application
No login required
No backend required
Persistent browser storage
Responsive interface
Interactive 3D flashcards
Custom flashcard decks
Flashcard-based quiz generation
Timed quizzes
Instant quiz feedback
Pomodoro productivity tracking
Web Audio feedback
AI-assisted development with Antigravity + Gemini Flash 8

Built With

HTML5 • CSS3 • JavaScript • LocalStorage API • Web Audio API • Antigravity • Gemini Flash 8

Thanks for checking out StudyBuddy! 🚀