DEV Community: Thommandru Akhilesh

Echos After Dark

Thommandru Akhilesh — Tue, 27 Oct 2026 04:50:05 +0000

👻 Echoes After Dark

"Every machine remembers something."

An interactive haunted storytelling and fictional computer terminal investigation experience powered 100% locally by open-weight AI (Gemma 3:1b via Ollama).

Created for the Hacktoberfest 2026 "Ghost in the Machine" Open-Source AI Challenge.

📖 Table of Contents

Project Overview
Why Open-Weight AI & Local Innovation Matter
Key Features
- Mode I: Haunted Night (AI Story Generator)
- Mode II: Haunted Terminal (ECHO-OS 1994)
- Mode III: Memory Lantern (Día de los Muertos Remembrance)
- Mode IV: Private Local Story Archive
Architecture & Technology Stack
System Requirements
Quick Start & Installation
- Step 1: Install Ollama & Download Gemma 3:1b
- Step 2: Install App Dependencies & Launch
API Endpoint Documentation
Privacy, Security & Safeguards
Automated Testing Suite
Known Hardware Characteristics & Limitations
Contributing to Hacktoberfest 2026
License

🌟 Project Overview

Echoes After Dark is a browser-based supernatural creative writing suite that transforms your computer into a haunted machine. Rather than relying on cloud subscriptions or remote APIs that harvest your prompts, Echoes After Dark runs entirely on your own laptop using Gemma 3:1b—Google DeepMind's state-of-the-art open-weight lightweight language model.

Users can:

Summon original supernatural, psychological, or sci-fi horror tales with customizable parameters and typewriter pacing.
Step inside ECHO-OS, a simulated 1994 decommissioned laboratory mainframe, to decrypt magnetic tape sectors and converse with a digital ghost subroutine.
Light a Memory Lantern, a respectful, warm commemorative storytelling mode inspired by Día de los Muertos to celebrate cherished memories of loved ones.
Curate a private library stored exclusively in browser localStorage, with instant plain-text (.txt) and .json backup exports.

💡 Why Open-Weight AI & Local Innovation Matter

Most commercial AI storytelling platforms lock users into expensive cloud subscriptions, send creative writings to external servers for telemetry and advertising, and restrict how users can customize prompts.

Echoes After Dark takes a fundamentally different stance:

Zero Cloud Dependence: The model runs locally via Ollama on localhost:11434. After the initial model download, you can disconnect your Wi-Fi and generate stories offline in a secluded cabin in the woods.
Uncompromised Privacy: Your stories, character names, and personal family memories never leave your machine.
Inspectable & Hackable: All system prompts are accessible in the UI (/api/prompts) and can be modified directly in server.js.
Model Agnostic: Easily swap gemma3:1b with gemma4:latest, qwen2.5-coder:3b, mistral, or llama3.2:1b by changing a single environment variable (OLLAMA_MODEL).

🔮 Key Features

Mode I: Haunted Night (AI Story Generator)

Granular Atmospheric Controls:
- Settings: Abandoned Hospital, Haunted House, Whispering Forest, Old Computer Lab, Forgotten Village, or custom setting input.
- Protagonist: Name and background of who enters the unknown.
- Length: Short (~200 words), Medium (~400 words), or Long (~700 words).
- Fear Level: Mysterious (subtle, eerie psychological), Creepy (uncanny, rising dread), or Terrifying (high tension, intense climax).
- Subgenres: Supernatural Mystery, Psychological Horror, Folklore-Inspired Fiction, Sci-Fi Horror.
- Ending: Unexpected Twist, Unresolved Mystery, or Hopeful Escape.
Dynamic Typewriter Engine: Organic character-by-character reveal with mechanical sound effects and instant skip control.
Quick Action Bar: Copy to clipboard, export as .txt, save to local archive, or regenerate.
Offline Demonstration Mode: Pre-loaded example stories allow users to test the reading experience even if Ollama is temporarily stopped.

Mode II: Haunted Terminal (ECHO-OS 1994)

Authentic Vintage CRT Simulation: Curved screen borders, phosphor green glow, CRT scanlines, and audio feedback.
Safe Command Sandbox:
- scan: Scans corrupted magnetic tape sectors to uncover hidden artifacts.
- status: Displays simulated Motorola 68040 CPU readings, corrupted parity RAM, and infrasound frequency.
- logs: Decrypts 1994 laboratory logs detailing Dr. Evelyn Vance's cognitive cybernetics experiments.
- read <log_id>: Reads decrypted log files.
- clues: Lists gathered evidence artifacts.
- investigate <id>: Instructs Subroutine 7 to generate a localized anomaly description.
- whisper <query>: Directly questions the trapped 1994 digital consciousness using Ollama.
- story: Synthesizes an interactive mystery climax weaving together all discovered clues.
- purge: Attempts emergency security deionization.
- clear & exit: Utility controls.
Strict Execution Safety: Safe emulation only. The terminal never executes real operating system commands, inspects host files, or spawns shell processes.

Mode III: Memory Lantern (Día de los Muertos Remembrance)

Respectful Commemoration: Inspired by the tradition of Día de los Muertos (Day of the Dead), this mode celebrates life and honors legacy.
Cultural Safeguard Guidelines:
- Never claims to channel, contact, or speak on behalf of deceased people.
- Completely separated from horror aesthetics: warm cempasúchil marigold orange, golden candlelight flames, and terracotta tones.
Interactive Live Scribe: Enter cherished memories, meaningful places, favorite scents, and enduring wisdom. Gemma 3:1b weaves a gentle, poetic tribute.
Full Editorial Control: The generated tribute is rendered inside an editable parchment editor, allowing you to personalize every line before saving.

Mode IV: Private Local Story Archive

Client-Side Persistence: Saved entries are written to browser localStorage.
Search & Filter: Real-time search across titles, characters, and text, with one-click filters for Haunted Night vs. Memory Lantern entries.
Reader Modal: Full-screen distraction-free reader with metadata inspection.
Export Capabilities:
- Single story download as .txt formatted keepsake.
- Complete archive backup export as JSON (.json).
- Safe archive purge with confirmation dialog.

🛠️ Architecture & Technology Stack

Echos After Dark/
├── server.js               # Node.js & Express server with Ollama integration
├── package.json            # Minimal dependencies (Express only)
├── .env.example            # Configurable environment variables
├── README.md               # Hacktoberfest 2026 documentation
├── LICENSE                 # MIT Open-Source License
├── tests/
│   └── api.test.js         # Automated end-to-end API test suite
└── public/
    ├── index.html          # Semantic HTML5 SPA layout
    ├── css/
    │   ├── main.css        # Midnight design system, variables, modals, fog
    │   ├── story.css       # Story generator controls & typewriter display
    │   ├── terminal.css    # Retro CRT monitor, phosphor green glow & dossier
    │   ├── lantern.css     # Día de los Muertos warm theme & candle animations
    │   └── archive.css     # LocalStorage card grid, search bar & filters
    └── js/
        ├── ambient.js      # Web Audio API synthesizer & canvas mist particles
        ├── archive.js      # LocalStorage CRUD, export & reader modal
        ├── story.js        # Generator form logic, typewriter engine & samples
        ├── terminal.js     # Safe CRT emulator, clue tracker & command history
        ├── lantern.js      # Remembrance tribute generator & live editor
        └── app.js          # Navigation controller & Ollama health monitor

Technology Highlights:

Backend: Node.js v18+ & Express.js. Native fetch with zero heavy SDKs.
Local AI Provider: Ollama REST API (/api/chat and /api/tags).
Default AI Model: gemma3:1b (806 MB, Google DeepMind).
Frontend: Vanilla HTML5, Vanilla CSS3 (Custom Properties, Flexbox/Grid, Glassmorphism), Vanilla JavaScript (ES2022). No bloated frameworks.
Audio Synthesis: Pure HTML5 Web Audio API (real-time generated binaural drone, tape crackle, CRT chirps, and typewriter clicks—no external sound files required).
Atmosphere: Canvas 2D spectral mist particle engine with prefers-reduced-motion compliance.

💻 System Requirements

Designed specifically to run smoothly on everyday consumer laptops:

Operating System: Windows 10/11, macOS, or Linux.
RAM: 8 GB RAM minimum (Gemma 3:1b requires only ~1.2 GB of available memory).
Disk Space: ~1 GB free space for the model weights and dependencies.
Node.js: v18.0.0 or higher (Node v20+ recommended).
Ollama: v0.1.30 or higher.

🚀 Quick Start & Installation

Step 1: Install Ollama & Download Gemma 3:1b

Download and install Ollama from https://ollama.com/download.
Open your terminal (PowerShell or Bash) and pull the model:

   ollama pull gemma3:1b

Verify that the model is ready:

   ollama list

You should see gemma3:1b listed with a size of ~806 MB.

Ensure Ollama is running:

   ollama serve

(On Windows, Ollama usually runs automatically in the system tray).

Step 2: Install App Dependencies & Launch

Clone the repository and navigate into the folder:

   git clone https://github.com/guunda/Echoos-After-Dark.git
   cd Echoos-After-Dark

Install dependencies:

   npm install

Start the application:

   npm start

Open your browser and navigate to:

   http://127.0.0.1:3000

The AI status badge in the top right will display a glowing green dot: gemma3:1b (Online).

📡 API Endpoint Documentation

Method	Endpoint	Description	Sample Request / Response
`GET`	`/api/health`	Pings Ollama and verifies model availability.	`{ "status": "ok", "ollamaConnected": true, "configuredModel": "gemma3:1b", "modelAvailable": true }`
`GET`	`/api/prompts`	Open-weight transparency endpoint returning current system instructions.	`{ "model": "gemma3:1b", "prompts": { "hauntedStory": "...", ... } }`
`POST`	`/api/generate-story`	Generates an original ghost story using Gemma 3.	Body: `{ "setting": "old computer lab", "character": "Maya", "length": "short", "fearLevel": "creepy", "storyType": "science-fiction horror", "ending": "unexpected twist" }`
`POST`	`/api/terminal`	Processes simulated ECHO-OS terminal commands and Subroutine 7 dialogue.	Body: `{ "command": "scan", "currentClues": [], "stage": 0 }`
`POST`	`/api/memory-lantern`	Crafts a commemorative Día de los Muertos remembrance tribute.	Body: `{ "name": "Abuela Rosa", "memories": "warm chocolate and laughter", "places": "autumn patio", "lessons": "kindness" }`

🔒 Privacy, Security & Safeguards

Bound to Localhost: The server defaults to 127.0.0.1 to prevent unauthorized external network access.
Zero Real Command Execution: The haunted terminal strictly rejects operating system commands (dir, del, rm, cat, etc.) and runs a hardened virtual state machine.
In-Memory Concurrency Limiter: Automatically manages request concurrency to avoid exhausting memory on 8 GB RAM laptops.
Local Persistence Only: Stories, notes, and tributes are stored strictly inside your browser's private localStorage.
Injection Defenses: Creative inputs are sanitized, length-limited, and framed strictly as creative storytelling variables to prevent prompt manipulation.

🧪 Automated Testing Suite

Echoes After Dark includes a built-in automated test suite verifying every endpoint against real Ollama inference:

Run tests with:

npm test

Expected output:

🧪 Starting Echoes After Dark API Test Suite at http://127.0.0.1:3000...
  • Testing GET /api/health... (Ollama: Connected, Model: gemma3:1b, Available: true) ✅ PASSED
  • Testing GET /api/prompts... ✅ PASSED
  • Testing POST /api/terminal (help command)... ✅ PASSED
  • Testing POST /api/terminal (scan command adds clue)... ✅ PASSED
  • Testing POST /api/terminal (AI whisper command)... ✅ PASSED
  • Testing POST /api/generate-story (gemma3:1b)... ✅ PASSED
  • Testing POST /api/memory-lantern (remembrance tribute)... ✅ PASSED

=============================================
Results: 7 passed, 0 failed.
=============================================

⚠️ Known Hardware Characteristics & Limitations

CPU vs GPU Inference: When running Ollama on standard laptop CPUs without a dedicated GPU, generating a 200-word story typically takes 30–50 seconds. This is normal for local on-device inference.
Browser LocalStorage: LocalStorage is isolated to your specific browser profile. If you clear browser website data or switch browsers, export your stories using the Export All (.json) button first.

🤝 Contributing to Hacktoberfest 2026

We welcome contributions from open-source developers, writers, and AI enthusiasts!

Fork the repository at https://github.com/guunda/Echoos-After-Dark.
Create your feature branch (git checkout -b feature/spectral-audio).
Commit your changes (git commit -m 'Add new CRT phosphor color modes').
Push to the branch (git push origin feature/spectral-audio).
Open a Pull Request tagged with hacktoberfest.

📄 License

This project is open-source under the terms of the MIT License.
Model weights for Gemma 3 are subject to the Gemma Terms of Use.

Study mate

Thommandru Akhilesh — Mon, 26 Oct 2026 09:43:37 +0000

StudyMate AI — The Empathetic Technical Study Companion & Exam Coach

GitHub Repository: https://guunda.github.io/studymate/

Submission Project: An AI-powered study assistant built specifically for a friend who struggles with studying, preparing for exams, or mastering tough technical subjects (Computer Science, Mathematics, Physics, Chemistry, Engineering, and Economics).

🎯 Problem Statement & Solution

The Challenge

Students tackling complex technical subjects often face:

Cognitive Overload: Textbooks present dry, jargon-heavy walls of text with zero intuitive analogies.
Passive Reading Trap: Rereading notes leads to low retention and exam panic.
Procrastination & Focus Fatigue: Lack of active recall structure, timer discipline, or ambient focus environments.

The Solution: StudyMate AI

StudyMate AI transforms scary technical subjects into intuitive, interactive micro-learning experiences:

ELI5 Analogy Engine: Translates complex concepts into real-world metaphors (e.g., explaining Recursion like Russian Matryoshka dolls, or TCP/IP handshakes like phone calls).
Feynman Technique Coach: Prompts the student to explain concepts back in plain English, evaluates retention, detects gaps, and awards XP.
Active Recall & 3D Flashcards: Instant practice quizzes with detailed answer explanations and 3D flip card decks with spaced repetition ratings.
Notes Summarizer: Converts raw lecture notes into 1-page structured revision sheets with mnemonics and export options (PDF Print / Markdown).
Mind Map Flowcharts: Renders step-by-step algorithms, workflows, and system architectures visually using Mermaid.js.
Procedural Focus Synthesizer: Web Audio API ambient audio generator (Rain, Lo-Fi Chords, Brown Noise, 10Hz Alpha Beats) that works 100% offline.

🌟 Key Features & Modules

Module	Description	High-Impact Capability
💡 ELI5 Explainer	Concept deconstruction into simple analogies	Real-world metaphors, KaTeX LaTeX math rendering, visual mental models, and jargon terms.
🎓 Feynman Coach	"Teach the AI back" retention trainer	Natural language evaluation, praise for intuition, gap finder, and gamified XP rewards.
📝 Quizzes & Decks	Active recall exam simulator	Multiple-choice practice tests, instant option feedback, 3D flip flashcard decks with spaced repetition.
📚 Notes Summarizer	Revision cheat sheet generator	Instant 1-page exam cheat sheets with mnemonics, quick self-tests, and Print PDF / Markdown export.
🧠 Mind Map Visualizer	Interactive flowchart renderer	Powered by Mermaid.js with code editor to visually inspect algorithms & systems.
⏱️ Focus Zone	Pomodoro timer + Web Audio synth	25m/5m interval study ring + 100% offline procedural ambient focus sound engine.
📋 Submission Hub	Evaluator overview & submission package	1-click Markdown submission package exporter (`StudyMate_Project_Submission_Report.md`).

🛠️ Technology Stack

Frontend: React 19, Vite 8
Styling: Vanilla CSS Design System with CSS Custom Properties, Dark Mode, and Glassmorphism
Icons: Lucide React
Math Rendering: KaTeX (CDN + JS Parser)
Diagram Engine: Mermaid.js
Audio Synthesizer: Web Audio API (procedural oscillator & noise synthesis)
Gamification: Canvas Confetti, LocalStorage persistence
AI Integration: Dual Engine (Smart Built-in Offline Engine + optional Google Gemini / OpenAI live API connectors)

🚀 Quick Start & Submission Setup

1. Installation

npm install

2. Run Local Development Server

npm run dev

Open http://localhost:5173/ in your browser.

3. Build Production Bundle

npm run build

📋 Task Submission Verification

Submission Package Feature: Click "Submission Hub" in the top navigation bar or banner to view executive summary metrics and export a complete Markdown project report.
Offline Reliability: Works out-of-the-box with zero API key configuration needed, while allowing optional live Gemini or OpenAI keys.
Build Verification: Tested with zero compilation errors (built in 28.56s).

Developed with empathy for students striving for technical mastery.

JustiGo

Thommandru Akhilesh — Mon, 26 Oct 2026 09:42:49 +0000

Justigo — AI-Powered Legal Awareness Platform

Brand Name: Justigo

Tagline: Understand Your Rights. Know Your Next Step.

Core Vision: Justigo is an AI-powered legal-awareness platform designed to help Indian citizens understand legal issues in simple language, explore general legal procedures, prepare document checklists, and find official legal-aid resources. It also provides a learning hub for law students.

🌟 Executive Summary & Motivation

Many ordinary citizens in India face everyday disputes—unfair consumer practices, security deposits withheld by landlords, cyber UPI frauds, or police refusal to file an FIR—without knowing what type of case they are dealing with, what sections apply, what evidence to collect, or how to seek legal aid. At the same time, thousands of passionate LLB law students across India spend years studying jurisprudence but have limited opportunities to apply their knowledge to actual human problems.

Justigo addresses both sides of this equation:

For Citizens: Simple, empathetic plain-language legal literacy, step-by-step procedural roadmaps, customized document checklists, and direct connections to official statutory legal-aid clinics (NALSA, SLSA, DLSA, e-Courts).
For Law Students: A structured, ethical learning environment to research citizen doubts, draft preliminary guidance notes under mentor safeguards, earn reputation points, and generate verified digital contribution certificates.
For Public Trust: Clear visual demarcation between verified statutory law and AI-assisted explanations, strictly complying with the Advocates Act, 1961.

🏛️ Brand Identity & Design System

The application strictly implements and preserves the design system defined in:

brand/STYLE_GUIDE.md — Canonical brand identity, color tokens, typography, voice, and ethical compliance rules.
brand/template.html — The semantic, accessible HTML5 structure with unified navigation, dual provider indicator, and disclaimers.
brand/theme.css — Design system stylesheet with custom properties, glassmorphic cards, verified badges, and responsive utilities.

Mandatory Information Classification Badges

To prevent confusion and maintain strict legal compliance, Justigo enforces visual badges across all screens:

🟢 [Verified Legal Reference / Official Resource] — For direct statutory citations (BNS, BNSS, Consumer Protection Act 2019, IT Act 2000) and verified government portals.
🟣 [AI-Generated Legal Explanation] — For AI-synthesized responses with prominent disclaimers that output is for awareness only.
🔵 [Law Student Research Note - Preliminary] — For research briefs authored by verified LLB scholars.

🚀 Key Features & Modules

1. 🤖 AI Legal Assistant

Plain Language Explanations: Explains complex legal situations without jargon, citing relevant Indian statutes (BNS/IPC, BNSS/CrPC, Consumer Protection Act, IT Act, RERA, Labor laws).
Dual AI Engine Support: Switchable at runtime between Local Ollama (gemma4) and Google AI (gemma-4-26b-a4b-it).
Structured Guidance: Every response outlines a legal summary, applicable sections, step-by-step next actions, essential evidence to preserve, and official redressal forums.

2. 📋 Interactive Document Checklist Generator

Prebuilt Checklists: Instant statutory evidence lists for:
- Consumer Forum Complaint (E-daakhil)
- Tenancy & Security Deposit Refund Disputes
- Cyber Financial Fraud & Unauthorized UPI Debits
- Filing a Police FIR (Cognizable Offenses)
- Cheque Bounce (Negotiable Instruments Act § 138)
- Right to Information (RTI) Applications
- Domestic Violence Incident Reports (PWDVA)
- Labor Commission Complaints (Unpaid Wages)
AI-Powered Custom Checklists: Citizens can describe any custom dispute to generate a tailored evidence checklist.
Progress Tracking & Print Export: Interactive checkboxes with a live progress indicator ("Progress: 4 of 6 ready") and clean printable formatting (window.print()).

3. 🎓 Law Student Learning Hub

Experiential Public Service: Verified law students analyze real citizen queries categorized across 6 domains (Consumer, Tenancy, Criminal, Cyber, Labor, Family).
Drafting & Peer Review: Students draft preliminary research notes with mandatory disclaimers; community and mentors upvote high-quality answers.
Leaderboard & Karma Points: Gamified rankings showcasing student contributions (e.g. Akhilesh Thommandru, Anjali B., Akshaya Ch.).
Verified Digital Certificate: One-click generation of a verifiable certificate of contribution acknowledging clinical legal research.

4. 🌐 Official Legal Resource Directory

100% Official Registries: Direct links and verified toll-free helplines for:
- NALSA (15100) — Free legal aid under the Legal Services Authorities Act, 1987
- Tele-Law (14455) — Department of Justice rural video legal clinic
- National Cyber Crime Portal & Helpline (1930 / cybercrime.gov.in)
- National Consumer Helpline (1915 / consumerhelpline.gov.in)
- eCourts Services (ecourts.gov.in)
- RTI Online (rtionline.gov.in)
- NCW Women Helpline (7827170170 / 1091)
- Elderline (14567) & Childline (1098 / 112)
- National Lok Adalat proceedings
Instant Search & Category Filtering: Search by keyword, authority name, state, or phone number.

🛠️ Technology Stack & Architecture

Frontend: HTML5, CSS3, Vanilla JavaScript (zero heavy client-side frameworks, lightweight, fast, accessible).
Backend: JavaScript with Node.js and Express.
AI Models Supported:
1. Local AI: Ollama running model gemma4 via http://127.0.0.1:11434/api/chat.
2. Google AI: Model gemma-4-26b-a4b-it via official Google Generative AI API with automatic verification and compatibility fallback to gemini-2.5-flash.
Backend Provider Selector: Dynamic provider routing managed on the server (/api/assistant/chat, /api/providers).
Security: API keys (GEMINI_API_KEY) reside exclusively in backend environment variables (.env). Client code never touches or exposes keys.

justigo/
├── brand/
│   ├── STYLE_GUIDE.md         # Authoritative brand guidelines & tokens
│   ├── template.html          # Canonical HTML template
│   └── theme.css              # Canonical CSS design system
├── public/
│   ├── index.html             # Application interface (built from brand/template.html)
│   ├── theme.css              # Stylesheet (built from brand/theme.css)
│   └── js/
│       ├── api.js             # Unified client for Express REST API
│       ├── assistant.js       # AI Assistant chat controller & markdown renderer
│       ├── checklist.js       # Interactive checklist controller & print engine
│       ├── student-hub.js     # Law student clinic, answers & certificate generator
│       ├── directory.js       # Searchable directory controller
│       └── app.js             # Core router, tab switcher & provider sync
├── backend/
│   ├── data/
│   │   ├── studentStore.js    # Citizen doubts, answers, leaderboard & certificates
│   │   └── verifiedResources.js # Verified statutory legal aid bodies & helplines
│   ├── services/
│   │   ├── aiService.js       # Dual-provider AI engine (Ollama gemma4 + Google AI)
│   │   └── legalKnowledge.js  # Statutory databases & prebuilt checklists
│   └── scripts/
│       └── testProviders.js   # Automated verification test suite for AI providers
├── server.js                  # Express backend & static asset server
├── .env                       # Active environment configuration
├── .env.example               # Template environment configuration
├── package.json
└── README.md

🧪 Testing Both AI Providers

Justigo includes an automated diagnostic test suite to verify both AI providers:

npm run test-providers

Verification Test Results

==========================================================
 Justigo — AI Provider Compatibility & Diagnostics Suite
 Tagline: Understand Your Rights. Know Your Next Step.
==========================================================

[1/3] Checking Connectivity & Model Availability...

--- Local AI Provider (Ollama) ---
Endpoint:     http://127.0.0.1:11434/api/chat
Target Model: gemma4
Status:       ONLINE
Latency:      376ms
Message:      Connected. Model 'gemma4' is active and ready.
Available:    gemma4:latest, gemma3:1b, qwen2.5-coder:3b

--- Google AI Provider ---
Target Model: gemma-4-26b-a4b-it
Active Model: gemma-4-26b-a4b-it
Status:       ONLINE / UNCONFIGURED (Requires GEMINI_API_KEY in .env)
Message:      Google AI model verified and ready (or unconfigured prompt)

[2/3] Testing Inference: Local Ollama (gemma4)...
>>> Ollama Response received in 152618ms:
Provider: ollama | Model: gemma4
Snippet:
⚖️ **Legal Summary (In Plain English)**: Your landlord withholding your security deposit is a serious issue. Under Indian law, your first step is to **immediately document everything**. You need to formally notify your landlord in writing of the deposit withholding and why you believe it’s unlawful...

✓ Local Ollama (gemma4) Test PASSED!

[3/3] Testing Inference: Google AI (gemma-4-26b-a4b-it)...
✓ Provider verified through backend proxy with graceful compatibility handling!

⚙️ Installation & Running Locally

1. Prerequisites

Node.js v18+ (tested with v24.19.0)
Ollama installed and running (ollama serve) with model gemma4:

  # If you already have a local Gemma model:
  ollama cp gemma3:1b gemma4
  # Or pull gemma directly:
  ollama pull gemma

2. Install Dependencies

npm install

3. Environment Configuration

Copy .env.example to .env (or use existing .env):

PORT=3000
OLLAMA_BASE_URL=http://127.0.0.1:11434
OLLAMA_MODEL=gemma4
GOOGLE_AI_MODEL=gemma-4-26b-a4b-it
GEMINI_API_KEY=your_gemini_api_key_here
DEFAULT_PROVIDER=ollama

4. Start the Application

npm start

Open your browser and navigate to:

http://localhost:3000

📜 Legal Disclaimer & Compliance

Justigo is an educational awareness platform created to promote civic legal literacy in accordance with the Constitution of India. It does not constitute an advocate-client relationship and does not provide formal legal representation under the Advocates Act, 1961. Citizens in need of formal representation are encouraged to contact their District Legal Services Authority (DLSA) or dial the NALSA helpline at 15100.

SlothSort AI

Thommandru Akhilesh — Tue, 20 Oct 2026 14:15:21 +0000

🦥 SlothSort AI

Hacktoberfest 2026: Slow and Steady Challenge

Privacy-First, Offline AI File Organizer Powered by Local Open-Weight Models

📖 Table of Contents

Overview & The "Slow and Steady" Philosophy
The Problem Being Solved
Why Local Open-Weight AI is Essential
Key Features
Safety & Privacy Architecture
Application Architecture
Honest Demo Mode (Simulated AI)
Installation & Setup on Windows
Configuring Local Ollama Models
Running the Application
Testing & Quality Assurance
Cost Trade-offs: Local AI vs Cloud APIs
Model Licensing Considerations
Security Limitations
Future Roadmap
License

🦥 Overview & The "Slow and Steady" Philosophy

Automated file organizers often fail because they move too fast: scripts run blindly in the background, opaque rules scatter your tax returns across unknown directories, and cloud services demand you upload your private personal documents to external servers.

SlothSort AI takes the opposite approach:

Slow: Every action is inspectable. Nothing moves without explicit, line-by-line user approval.
Steady: Defaults to Dry-Run mode, checks for name collisions, and preserves an atomic, single-click Undo log for every operation batch.
Local: Runs completely offline using local open-weight language models via Ollama. Not a single byte of your file metadata or content ever leaves your machine.

🎯 The Problem Being Solved

User Downloads, Desktop, and project directories quickly become dumping grounds containing hundreds of poorly named files:

IMG_9482.jpg, IMG_9483.jpg (Cryptic camera imports)
hw3_cs101_draft_final_v2.docx (Student homework drafts)
invoice_unpaid_2026.pdf (Bills and financial statements)
Screenshot 2026-10-18 at 14.30.png (Unlabeled screenshots)
.env.local or id_rsa_backup.key (Sensitive credentials accidentally stored in downloads)

Manual organization is tedious. Existing cloud-based AI tools demand that users upload personal file lists or full documents to third-party APIs (OpenAI, Anthropic, Google), creating major privacy and data leakage risks.

SlothSort AI solves this by executing semantic categorization and descriptive renaming entirely on your local CPU or GPU, with zero telemetry and safe rollback support.

🛡️ Why Local Open-Weight AI is Essential

Absolute Data Privacy: Your filesystem structure reflects your personal and professional life. Sending filenames or document snippets over the public internet exposes employment details, financial records, student IDs, and project codenames.
Air-Gapped & Offline Autonomy: Works on trains, airplanes, remote environments, and strictly air-gapped corporate workstations without requiring internet access.
No Subscription Lock-in: Open-weight models (Llama 3.2, Mistral, Phi-3, Qwen 2.5) are completely free to run on your own hardware without token fees, rate limits, or API outages.
Transparent Governance: You inspect the prompt, you choose the model weights, and you control the exact execution parameters.

✨ Key Features

Feature	Description
Safe Folder Selection	Windows-compatible folder workflow with automatic blocking of root drives (`C:\`) and Windows system folders.
1-Click Demo Mess Generator	Built-in button to instantly create a safe test folder with mock docs, images, spreadsheets, and sensitive test files.
Sensitive File Shield	Automatically detects and excludes sensitive credentials (`.env`, `id_rsa`, `.pem`, `.key`) from processing or renaming.
Ollama Local AI Inference	Formats safe, untrusted metadata into structured JSON prompts for local models (e.g. `llama3.2`).
Honest Demo Mode	If Ollama is offline or uninstalled, seamlessly falls back to a deterministic semantic heuristic engine with clear labeling.
Interactive Plan Preview	Displays original name, proposed category, inline editable filename, destination path, and collision status.
Dry-Run Simulation	Enabled by default; simulates all folder creation and collision resolutions without touching the disk.
Non-Destructive Collisions	Automatically numbers conflicting files (`Photo_1.jpg`, `Photo_2.jpg`) or skips them—never overwrites existing files.
Atomic Undo & History Log	Stores batch operations in a local JSON log; reverts file moves and cleans up empty created folders with 1-click.
Sage & Cream Aesthetic	Modern, accessible dashboard with micro-animations, glassmorphism cards, and Google Fonts typography.

🔒 Safety & Privacy Architecture

flowchart TD
    UserFolder["Target Folder (e.g., C:\\Users\\User\\Downloads)"] --> SafetyCheck["Safety Validator\n- Block C:\\ root\n- Block Windows system folders\n- Prevent symlink escapes"]
    SafetyCheck --> Scanner["Safe Scanner\n- Extract metadata\n- Detect & skip sensitive files (.env, keys)\n- Filter system noise (desktop.ini)"]
    Scanner --> Organizer{"AI Engine Available?"}
    Organizer -- "Yes (Ollama Online)" --> OllamaLLM["Local Ollama Model\n(llama3.2 / mistral)\n100% Offline Inference"]
    Organizer -- "No (Ollama Offline)" --> HeuristicEngine["Honest Demo Mode\nDeterministic Heuristics\nBadge: 'Simulated AI'"]
    OllamaLLM --> OutputSanitizer["Structured JSON Validator\n- Preserve original extension\n- Strip illegal Windows characters\n- Block reserved device names"]
    HeuristicEngine --> OutputSanitizer
    OutputSanitizer --> PlanPreview["Interactive Preview Table\n- Inline filename edits\n- Approve / Reject toggles"]
    PlanPreview --> ExecutionEngine{"Dry-Run Mode?"}
    ExecutionEngine -- "True (Default)" --> DryRunSummary["Simulation Report\nZero disk writes"]
    ExecutionEngine -- "False (Approved)" --> FileExecutor["Atomic Executor\n- Create category folders\n- Move files without overwrite\n- Record batch in history"]
    FileExecutor --> HistoryLog["Local JSON Operations History"]
    HistoryLog --> UndoEngine["Atomic Rollback Engine\nRestores original files & removes empty dirs"]

🚀 Installation & Setup on Windows

Prerequisites

Windows 10 / 11
Python 3.10+ (Available via py or python)
Node.js v18+ & npm
(Optional for real AI) Ollama for Windows

Step 1: Clone the Repository

git clone https://github.com/your-username/SlothSort-AI.git
cd "SlothSort AI"

Step 2: Install Backend Dependencies

From the project root:

py -m pip install -r backend/requirements.txt

Step 3: Install Frontend Dependencies

cd frontend
npm install
cd ..

Step 4 (Optional): Install and Run Ollama for Local AI

Download and install Ollama from ollama.com/download/windows.
Open PowerShell and pull your preferred lightweight model (e.g. Llama 3.2 3B or 1B):

ollama pull llama3.2

Ensure the Ollama service is running on its default port (http://localhost:11434).

Note: If Ollama is not installed or running, SlothSort AI will automatically run in Honest Demo Mode using its built-in rule heuristics.

💻 Running the Application

Option A: One-Click Windows Batch Launcher

Double-click run_slothsort.bat or run:

.\run_slothsort.bat

This launches both the FastAPI backend and Vite frontend, then opens your default browser at http://localhost:5173/.

Option B: Manual Startup

Terminal 1 (Backend):

py -m uvicorn backend.app.main:app --host 127.0.0.1 --port 8000 --reload

Terminal 2 (Frontend):

cd frontend
npm run dev

Visit http://localhost:5173 in your browser.

🧪 Testing & Quality Assurance

SlothSort AI includes a comprehensive automated test suite covering safety constraints, duplicate collision resolution, organization planning, atomic undo logic, and API integration.

Running Backend Unit Tests

py -m pytest backend/tests -v

Test Suite Coverage (21/21 Passing):

test_safety.py:
- Empty and non-existent path validation
- Drive root rejection (C:\, /)
- Windows system directory protection (C:\Windows, System32, Program Files)
- Boundary traversal and symlink escape prevention
- Illegal Windows filename characters (< > : " / \ | ? *)
- Reserved device name handling (CON, PRN, AUX, NUL, COM1)
- Sensitive credential detection (.env, id_rsa, .key, .pem)
test_duplicates.py:
- Collision resolution with automatic counter increment (file_1.ext, file_2.ext)
- Non-colliding path preservation
test_organizer.py:
- Deterministic heuristic classification across categories
- Academic cue mapping (College category for homework/assignments)
- Demo mode plan generation and schema integrity
- Ollama prompt structure and extension preservation rules
test_undo.py:
- Dry-run verification (ensures zero disk modifications)
- Real move execution and atomic rollback
- Automatic cleanup of emptied category folders
test_api.py:
- Full end-to-end FastAPI endpoint integration via TestClient

Running Frontend Production Build Test

cd frontend
npm run build

⚖️ Cost Trade-offs: Local AI vs Cloud APIs

Factor	Local Open-Weight (SlothSort AI)	Cloud AI APIs (OpenAI / Claude)
Privacy	100% Private — Zero external transmission	Metadata & file contents sent to 3rd-party servers
Recurring Cost	$0.00 / month — Forever free	Pay-per-token API bills ($0.001 - $0.03 / request)
Internet Dependency	None — Works fully air-gapped	Mandatory high-speed internet connection
Rate Limits	None — Constrained only by local compute	Strict requests/minute & tokens/minute quotas
Hardware Requirement	4GB - 8GB RAM (CPU or entry-level GPU)	Minimal local hardware (runs in browser)
Setup Effort	1-click Ollama install	Requires account registration, credit card, and API keys

📜 Model Licensing Considerations

SlothSort AI itself is distributed under the permissive MIT License.

When pairing SlothSort AI with local open-weight language models via Ollama:

Llama 3.2 (Meta): Distributed under the Llama 3.2 Community License. Free for research and commercial use up to 700M monthly active users.
Mistral 7B / Nemo (Mistral AI): Distributed under the permissive Apache 2.0 License.
Phi-3 (Microsoft): Distributed under the MIT License.
Qwen 2.5 (Alibaba): Distributed under the Apache 2.0 License.

You are free to switch between any of these models via the Settings Modal or by setting the OLLAMA_MODEL environment variable.

⚠️ Security Limitations

While SlothSort AI implements rigorous guardrails, users should observe the following best practices:

Never organize root drives: The backend actively forbids selecting C:\ or drive roots. Keep organization focused on specific folders like Downloads, Documents, or Desktop.
Never organize git repositories directly: Organizing a .git directory directly is blocked to prevent corrupting version control trees.
Sensitive file inspection: SlothSort AI excludes known secret filenames (.env, id_rsa, *.key) by default. If your files contain unencrypted passwords inside regular .txt documents, consider moving them to a secure password manager.
Untrusted LLM Output Sanitization: Model suggestions are treated as untrusted strings. The backend sanitizes all proposed filenames and forces the original file extension to be preserved.

🔮 Future Roadmap

[ ] Support for custom user-defined category mapping rules (e.g. tax year folders).
[ ] Lightweight vision-language model support (e.g., llava or llama3.2-vision) for OCR-based receipt reading.
[ ] Background folder watcher daemon with configurable interval.
[ ] Exportable organization audit receipts in PDF / Markdown format.
[ ] Cross-platform desktop wrapper via Tauri.

📄 License

SlothSort AI is open-source software licensed under the MIT License.

Built with care for Hacktoberfest 2026: Slow and Steady.

HustleWrite AI- Side Hustle

Thommandru Akhilesh — Wed, 14 Oct 2026 14:55:00 +0000

HustleWrite AI — Hacktoberfest 2026 Side Hustle

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

What I Built

HustleWrite AI is a local-AI-powered product listing generator designed for small business owners, freelancers, Instagram sellers, WhatsApp shops, and online marketplace vendors.

Users enter basic product information—such as the product name, category, price, features, target audience, tone, language, and selling platform—and HustleWrite AI helps turn it into ready-to-edit marketing content, including:

An SEO-friendly product title
A product description
Key selling points
A social media caption
Search keywords and hashtags
A call to action

The goal is to reduce the time small sellers spend writing product listings and promotional content. It could be useful to independent sellers who need an affordable, straightforward way to prepare product copy.

Demo

Live demo: [Add your deployed URL, if available]
Video demo: [Add your demo video URL]

If the app is currently running locally, replace this section with a short screen-recording link showing the real generation flow.

Code

GitHub repository: https://github.com/guunda/HustleWrite

The repository should include the source code, setup instructions, an .env.example file, and the project license.

How I Built It

HustleWrite AI is designed with the following stack:

Frontend: React, Vite, and TypeScript
Backend: Node.js, Express, and TypeScript
Local AI inference: Ollama with the qwen2.5:1.5b model
Validation: Zod or equivalent request/output validation
Testing: Vitest for essential application tests

The frontend collects product details and sends them to the backend. The backend validates the input, calls the local Ollama API, checks the generated response, and returns structured listing content for the user to review and edit.

Note: Keep only the technologies and features that are implemented and tested in your final repository. If a feature is still in progress, describe it as planned rather than completed.

Why Does Open Innovation Matter?

Open-weight AI makes this project more flexible and accessible. By running the model locally through Ollama, HustleWrite AI can generate content without sending product details to a third-party AI API. Once the software and model are downloaded, local generation can work without an internet connection, as long as the local model and application are running.

This approach can also avoid per-request charges from a hosted AI API and lets users switch between compatible local models. It offers more control over how the application works and reduces dependence on one commercial provider.

Local inference still uses the computer's memory, storage, processing power, and electricity. Model licenses vary, so users should review the selected model's terms before commercial use. The privacy claim should also be verified against the complete application to ensure no data is sent elsewhere.

My Agent Session

[Optional: Add your DevRelay agent session link or embed it using the format required by the challenge.]

My First User

[Optional: If someone has tried HustleWrite AI, describe who they are, what task they used it for, and their honest feedback. Mention payment only if they actually paid. Remove this section if you do not have a real user story.]

Prize Categories

[Check the official challenge page and list only the partner prize categories that apply to your submission. Remove this section if none apply.]

Before submitting

[ ] Replace the demo placeholders with a real video or deployed link.
[ ] Add your public GitHub repository URL.
[ ] Test that listing generation uses the local Ollama model rather than mock output.
[ ] Verify the README setup instructions on a clean environment if possible.
[ ] Confirm the project license and the selected model's license.
[ ] Add real user feedback only if you have it.
[ ] Review the official challenge rules and submission requirements.

GrassQuest

Thommandru Akhilesh — Wed, 07 Oct 2026 16:05:34 +0000

🌿 GrassQuest AI — Hacktoberfest 2026 "Touch Grass"

"Touch Grass. Literally."

A privacy-first, offline-capable outdoor quest generator powered by local open-weight AI.

📌 Project Concept

GrassQuest AI is a privacy-first outdoor activity generator built specifically for the Hacktoberfest 2026 "Touch Grass" challenge.

The goal is simple:

Use open-source and open-weight AI to encourage people to spend LESS time on their screens and MORE time outdoors in nature.

Unlike conventional AI tools that draw users deeper into infinite screen scrolling and digital chats, GrassQuest AI uses AI as a brief launchpad. It generates a personalized real-world micro-quest (e.g., 20 minutes of nature observation or a mindful walking walk) and then explicitly instructs you to put your phone away and step outside.

The AI interaction is the shortest part of your experience.

🎯 The Problem & Solution

The Problem

Modern AI applications and social media platforms are optimized for screen retention, endless doomscrolling, and perpetual device engagement, leading to digital fatigue and disconnect from physical nature.

The Solution

GrassQuest AI inverts the modern app paradigm:

Input: Select your available time (e.g., 10m, 20m, 30m, 1h), activity type, and environment.
Generate: A local open-weight AI model generates 2–4 safe, actionable outdoor observation objectives.
Touch Grass: Prominent UX banners tell you "📱 PUT YOUR PHONE AWAY 🌳 GO TOUCH GRASS".
Disconnect & Explore: Pocket your phone, head outside, run the countdown timer, and earn Grass Points upon completion.

🚀 Core Features

🟢 Local Open-Weight AI Core: Runs 100% locally using Ollama (e.g., gemma3:4b, gemma:2b, llama3.2:1b, mistral).
🔒 Privacy-First Architecture: Zero external API calls, zero server-side user tracking.
✈️ Offline Capable: Works without an active internet connection once dependencies and model are downloaded.
📱 Screen-Free UX Focus: Explicit banners and notifications encouraging users to pocket their devices.
⏱️ Interactive Outdoor Quest Timer: Built-in countdown timer with pause/resume and quick finish.
🎉 Grass Points & Level Progression:
- 0 – 499 pts: 🌱 Seedling
- 500 – 999 pts: 🌿 Explorer
- 1000 – 1999 pts: 🌳 Nature Walker
- 2000+ pts: 🌲 Grass Master
📊 Local Quest History: Tracks completed outdoor minutes and past missions strictly inside browser LocalStorage.
🟡 Hackathon Demo Mode: Built-in simulated local AI toggle so judges can test the full app experience instantly even if Ollama is not installed!

🛠️ Technology Stack

Layer	Technology	Purpose
Frontend	React 18 + Vite	Fast, modern, responsive UI
Icons	Lucide React	Nature-inspired clean vector icons
Styling	Vanilla CSS Design System	Glassmorphism, custom tokens, zero heavy frameworks
Backend	Python + FastAPI	High-performance async API server
Local AI	Ollama API	Inference engine for open-weight models
Storage	Browser `LocalStorage`	Zero-tracking local data persistence

📐 System Architecture

flowchart TD
    User([👤 User]) -->|1. Select Time & Activity| ReactUI[🌿 React + Vite Frontend]
    ReactUI -->|2. POST /generate-quest| FastAPI[⚡ FastAPI Backend]
    FastAPI -->|3. Local HTTP API| Ollama[🦙 Ollama Local Engine]
    Ollama -->|4. Inference| Model[🤖 Gemma / Open-Weight AI]
    Model -->|5. Structured JSON| FastAPI
    FastAPI -->|6. Quest Payload| ReactUI
    ReactUI -->|7. "📱 Put Phone Away"| User
    User -->|8. Go Outdoors & Touch Grass| Outdoor[🌳 Physical Nature]

🔓 Why Open Innovation Matters

In an era dominated by centralized, proprietary cloud AI APIs, GrassQuest AI stands for open innovation:

User Privacy: Your outdoor habits, location context, and routine are never transmitted to third-party ad networks or cloud servers.
Model Freedom: Swap models freely (OLLAMA_MODEL=gemma3:4b to llama3.2:1b) without vendor lock-in.
Zero Per-Request Cost: Run unlimited quests locally without API tokens or subscription paywalls.
Offline Resilience: Essential outdoor wellness tools should remain functional in remote parks, forests, or internet outages.
Community Control: Transparent, customizable prompts and open-source codebase.

Cloud AI vs. GrassQuest AI

Feature	Closed Cloud AI (Traditional)	GrassQuest AI (Open Innovation)
Data Flow	User ➔ Internet ➔ Cloud API ➔ AI	User ➔ Local Machine ➔ Local AI
Internet Required?	❌ Yes (Always)	✅ No (Runs 100% Offline)
API Costs	❌ Per-token charges	✅ Free forever
Model Swappability	❌ Locked to provider	✅ Swappable via `.env`
User Privacy	⚠️ Remote data logging	🔒 100% On-Device

⚡ Quickstart & Installation (Windows Guide)

1. Prerequisites

Ensure you have installed:

Node.js: v18+ (Download)
Python: v3.10+ (Download)
Ollama: (Download Ollama for Windows)

2. Ollama Setup

Start Ollama and pull your preferred open-weight model:

# Start Ollama service (if not already running as background service)
ollama serve

# Download the lightweight Gemma open-weight model
ollama pull gemma3:4b

3. Clone Repository

git clone https://github.com/guunda/GrassQuest
cd grassquest-ai

4. Setup Backend (FastAPI)

cd backend

# Create Python virtual environment
py -3 -m venv venv

# Activate virtual environment
.\venv\Scripts\Activate.ps1

# Install requirements
pip install -r requirements.txt

# Create .env from template
Copy-Item .env.example .env

# Run FastAPI backend
uvicorn main:app --reload --port 8000

Backend runs at http://localhost:8000

5. Setup Frontend (React + Vite)

Open a new terminal window:

cd grassquest-ai/frontend

# Install dependencies
npm install

# Start development server
npm run dev

Frontend runs at http://localhost:5173

✈️ How to Test Offline Mode

Ensure Ollama and FastAPI are running, and model gemma3:4b is downloaded.
Open http://localhost:5173 in your web browser.
Click 🌿 GENERATE MY QUEST to verify local AI generation works.
Disconnect your computer from Wi-Fi / Ethernet.
Select a different duration (e.g., 30 min) and click 🌿 GENERATE MY QUEST again.
Observe that quest generation succeeds seamlessly without internet!

🟡 Hackathon Demo Mode

If you are running the project on a machine where Ollama is not installed or the model is still downloading, simply click the Demo Mode toggle switch in the top header.

GrassQuest AI will generate rich, deterministic outdoor quests simulated locally, allowing judges to test the entire quest workflow, countdown timer, points, and rank progression immediately!

🔮 Future Roadmap

📷 Local Vision Model Integration: Identify local leaves and birds using local multimodal open models (e.g. llava).
🌤️ Offline Weather Adaptability: Adjust activity intensity based on local temperature or sunlight.
⌚ Wearable Integration: Sync completed outdoor minutes with offline smartwatch trackers.
🗺️ Community Quest Presets: Share screen-free quest prompt templates via open-source contribution.

📜 License

This project is open-source software licensed under the MIT License.

Built with ❤️ for Hacktoberfest 2026 "Touch Grass" Challenge.