DEV Community: Aryan Mohan

ZenSloth: An Offline-First Bedtime Companion Built for the Art of Doing Nothing

Aryan Mohan — Sun, 25 Oct 2026 13:01:18 +0000

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

What I Built

In celebration of International Sloth Day and the Slow and Steady theme, I built ZenSloth — a private, offline-first bedtime sleep companion and ambient narrative generator that invites you to slow down, conserve your energy, and do absolutely nothing.

Modern bedtime apps and AI tools are full of stimulation: subscription paywalls, notifications, cloud tracking, dopamine loops, and chatbots trying to solve problems. ZenSloth does the exact opposite. Channeling the unhurried spirit of a sloth, it creates a calming, low-stimulation cocoon for your mind:

🦥 Unrushed Ambient Narratives: Generates calming, low-stimulation bedtime stories and mindful meditations tailored to 4 serene archetypes (The Sloth Sanctuary, Ancient Moss Forest, Rainy Cedar Cabin, and Velvet Twilight).
🌊 Procedural Soundscape Synthesizer: Four ambient channels (Deep Brown Noise, Gentle Rain, Soft Wind, and Warm Hearth) synthesized 100% on the fly in the browser using the Web Audio API — no gigabytes of looping audio files or buffering.
🫁 4-7-8 Sloth Breathing Guide: A gentle pulsing orb with a warm amber glow guiding a 4-second inhale, 7-second hold, and 8-second exhale to trigger the body's natural relaxation response.
🔒 100% Local & Private: Powered by local open-weight inference with Ollama. No personal sleep notes or bedtime thoughts ever leave your machine.

ZenSloth lets you be as lazy as possible: pick a mood, tap once, close your eyes, and drift off to sleep.

Demo

ZenSloth is an offline-first companion designed to run privately and reliably on your own machine without third-party cloud tracking.

Run Locally with Docker (One Command)

Clone the repository and spin up the containers:

git clone https://github.com/AryanMohan818/ZenSloth.git
cd ZenSloth
docker compose up -d

Pull the lightweight open-weight model:

docker exec -it zensloth-ollama ollama pull qwen2.5:1.5b

Open http://localhost:3000 in your browser, lay back, and enjoy your wind-down session.

Code

AryanMohan818 / ZenSloth

This is a Next.js project bootstrapped with create-next-app.

Getting Started

First, run the development server:

npm run dev
# or
yarn dev
# or
pnpm dev
# or
bun dev

Open http://localhost:3000 with your browser to see the result.

You can start editing the page by modifying app/page.tsx. The page auto-updates as you edit the file.

This project uses next/font to automatically optimize and load Geist, a new font family for Vercel.

Learn More

To learn more about Next.js, take a look at the following resources:

Next.js Documentation - learn about Next.js features and API.
Learn Next.js - an interactive Next.js tutorial.

You can check out the Next.js GitHub repository - your feedback and contributions are welcome!

Deploy on Vercel

The easiest way to deploy your Next.js app is to use the Vercel Platform from the creators of Next.js.

Check out our Next.js deployment documentation for more…

View on GitHub

How I Built It

ZenSloth is built entirely around an open-source, local-first stack designed for calm aesthetics, zero network latency, and complete privacy:

1. Local Open-Weight Inference with Ollama (`qwen2.5:1.5b`)

Bedtime apps shouldn't depend on cloud API rate limits, subscription keys, or internet connectivity. ZenSloth uses Ollama running lightweight open-weight models (defaulting to qwen2.5:1.5b).

Low-Stimulation Prompt Engineering: The system prompt enforces strict calming narrative rules: short 2–3 sentence paragraphs, sensory-rich textures, zero cliffhangers, and natural drowsiness pacing (250–350 words).
Edge Streaming: The Next.js Route Handler (/api/generate) leverages ReadableStream to stream tokens directly from Ollama to the browser in real-time, giving listeners an immediate, flowing experience without waiting for full generation.

2. Pure Procedural Web Audio Engine

Instead of bundling heavy MP3 assets or streaming audio over Wi-Fi, ZenSloth includes a custom procedural audio engine built on the native Web Audio API:

Brown Noise: Continuous noise filtered through a lowpass biquad filter at 400Hz to mask room sounds.
Rain: Pink noise algorithm passing through a 1000Hz filter.
Wind: Low-frequency bandpass-filtered noise with organic gain modulation.
Fireplace Hearth: Brown noise interspersed with algorithmic crackle and pop bursts.

3. Next.js 16 + Tailwind CSS v4

Next.js 16 (App Router) & React 19: Built with standalone output and containerized with Docker.
Tailwind CSS v4: Designed with an ultra-dark palette (#07080b), soft amber/stone hues, and blur filters to minimize blue light before sleep.
Docker Compose: Orchestrates both the frontend web app and Ollama service with persistent model caching.

Why Does Open Innovation Matter?

Your bedroom is your most personal, private space. When you tell a sleep app about the anxiety keeping you awake, your racing thoughts, or your bedtime routine, that data shouldn't be packaged into an advertising profile or logged on proprietary cloud servers.

Open innovation made ZenSloth possible in ways closed APIs never could:

Complete Privacy & Offline Capability: By using open-weight models with Ollama, ZenSloth can run on an airplane, in a rustic cabin off the grid, or with Wi-Fi completely turned off. Closed AI models break the moment your internet disconnects.
Freedom from Subscriptions: Closed sleep apps frequently lock soundscapes and stories behind expensive annual paywalls. With open-weight AI and browser-synthesized audio, this app belongs to the user forever.
Low-Resource Accessibility: Open-weight models like qwen2.5:1.5b run smoothly on standard laptops and budget mini-PCs without needing expensive enterprise GPUs.

The Lazy Payoff

Building bedtime routines usually feels like work: searching for a meditation podcast, adjusting white noise playlists, skipping mid-roll ads, or staring at bright screens trying to decide what to listen to.

ZenSloth reduces all of that friction to zero effort:

One click sets the scene, balances the ambient rain, wind, and brown noise, starts the 4-7-8 breathing guide, and streams an unhurried, gentle bedtime story.
Time & Effort Saved: 15–20 minutes of nighttime screen scrolling replaced by instant relaxation.
Tested this week for actual bedtime wind-downs: no ads, no cliffhangers, and zero blue light overload.

Prize Categories

Overall Winner (Hacktoberfest Open-Source AI Challenge: Week 3 - Slow and Steady)
Best Use of Gemma (Powered locally via Ollama using Google's open-weight gemma2:2b)

Leadger Guard

Aryan Mohan — Sun, 18 Oct 2026 15:36:39 +0000

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

What I Built

LedgerGuard is an open-source, 100% local and offline AI assistant designed for freelancers, indie hackers, and solo contractors to manage invoices, track real-time cash flow, and recover unpaid client revenue.

The Problem It Solves

Freelancers lose hundreds of dollars and countless hours chasing late invoices and untangling cash flow. Existing SaaS platforms (like QuickBooks or FreshBooks) charge \$30–\$70/month and require uploading confidential client contracts, billing rates, banking details, and NDA-bound deliverables to external corporate cloud servers.

Who Would Pay For It?

Solo Freelancers & Contractors: Creators, developers, and consultants who want to keep their financial data strictly confidential while automating tedious invoice tracking.
Privacy-First Micro-Agencies: Small teams with strict client NDAs that prohibit processing proprietary project scopes through commercial cloud LLM APIs.
Bootstrapped Indie Hackers: Builders who want a zero-maintenance, zero-subscription tool to stay on top of overdue receivables.

LedgerGuard solves this by providing:

Intelligent Invoice & Receipt Extraction: Parses messy raw invoices, amounts, line items, due dates, and payment terms into structured records.
Real-time Cash Flow Ledger: Live tracking of invoiced, collected, and outstanding balances with instant CSV reporting.
Smart Follow-up Drafter: Generates personalized, tone-calibrated client payment reminders (Friendly, Professional & Firm, or Urgent) to accelerate settlements.

Code

🔗 Repository: https://github.com/your-username/ledgerguard*

How I Built It

LedgerGuard is architected from the ground up around local, open-weight AI inference:

Open-Weight AI Models: Powered by local models like Gemma 2 (gemma2:2b) and Llama 3.2 running locally via Ollama. By hitting Ollama's local HTTP API (/api/generate) with structured JSON mode, LedgerGuard extracts tabular data from freeform text with sub-second latency on standard laptop hardware.
Zero-Dependency Offline Fallback: Includes a built-in deterministic heuristic engine. If Ollama is not installed or running, LedgerGuard seamlessly falls back to local regex extraction and smart templates, guaranteeing 100% functionality without internet.
Frontend & Ledger Core: Built using Streamlit for a lightweight, reactive web UI and Pandas for in-memory ledger aggregation, overdue metrics calculations, and CSV exports.
Reproducible Packaging: Packaged into a lightweight Docker container for frictionless zero-setup execution on any OS.

Why Does Open Innovation Matter?

Open innovation is what made LedgerGuard possible, where closed proprietary APIs fail:

Absolute Data Privacy & NDA Protection: Financial records, hourly rates, and client deliverables are confidential. Feeding sensitive client billing records into closed proprietary cloud APIs can violate non-disclosure agreements (NDAs). Open-weight models running on local hardware ensure data never leaves the user's laptop.
True $0 Marginal Operating Cost: Commercial cloud APIs charge per token and impose monthly platform fees. With local open-weight models, freelancers can parse hundreds of invoices without incurring a single cent in API bills.
Unbreakable Reliability & Offline Freedom: Freelancers frequently travel or work in places with unstable internet. Open weights run locally on planes, trains, and remote spots without requiring an active internet connection.
No Deprecation or Vendor Lock-in: Open-source AI cannot be abruptly discontinued, price-hiked, or rate-limited by an external API provider.

Prize Categories

Best Use of Gemma: Uses Google's open-weight Gemma 2 (gemma2:9b-it) for structured JSON extraction and natural-language payment reminder drafting.
Best Use of Render / DigitalOcean: Packaged with Docker for deployment on Render Web Services or DigitalOcean App Platform.

TrailPulse: The Open-AI Outdoor Companion That Wants You to Close Your Screen

Aryan Mohan — Sun, 11 Oct 2026 17:50:24 +0000

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

What I Built

Most modern outdoor and fitness apps do the exact opposite of what they claim: they trap you in infinite feeds, leaderboard notifications, and step badges. You end up looking at glass instead of grass.

TrailPulse was built with a single rule: the screen must be the shortest part of the experience.

It is a lightweight, anti-screen outdoor companion designed for students, developers, and desk-bound workers who want to disconnect without overplanning. In under 30 seconds:

You select your immediate outdoor environment (Park, Trail, Backyard, or Urban Walk) and your available time (10m to 60m).
An open-weight model generates a focused, 3-task sensory micro-mission (e.g., sound identification, tactile ground observation, or canopy awareness).
With a single tap, it reads the mission hands-free through your earbuds and locks into a pure-black "Pocket Disconnect Mode" with an ambient timer so your phone stays in your pocket while you step outside.

Demo

Live Deployed App: (https://trialpulse-1ev8.onrender.com)

Code

The complete source code, Docker configuration, and documentation are available on GitHub:(https://github.com/AryanMohan818/TrialPulse)

How I Built It

TrailPulse was engineered from the ground up for low-friction execution and zero cloud vendor lock-in:

AI Core (Open Weights): Powered by Google's open-weight Gemma 2 (google/gemma-2-2b-it). We prompt Gemma to act as a nature-grounding guide, constraining output strictly to under 80 words with three distinct sensory checkpoints.
Offline Fault-Tolerance: Because outdoor trails frequently have spotty or zero cellular reception, TrailPulse features a dual-mode engine. If an API key is absent or connectivity drops off-grid, a local heuristic nature engine takes over instantaneously without error screens.
Backend & Serving: Built with FastAPI (Python 3.11) and Uvicorn for asynchronous speed and micro-footprint memory usage.
Anti-Screen Frontend: A single, responsive interface styled in dark nature tones with zero heavy front-end frameworks. It integrates the native Web Speech API for hands-free audio briefings.
Containerization & Deployment: Packaged into a minimal Docker container (python:3.11-slim) and deployed on Render as a cloud web service.

Why Does Open Innovation Matter?

Open innovation is not just an architectural choice for TrailPulse — it is the fundamental reason the project works:

Trail Resilience & True Off-Grid Mobility: Proprietary closed-source LLMs force an active, high-bandwidth connection to remote corporate servers. When you are on a hiking trail or deep in a park with zero signal, closed APIs fail completely. Open-weight models like Gemma can be packaged directly into local edge containers and laptops to generate missions anywhere on the planet.
Anti-Surveillance & Data Ownership: A user stepping outside to de-stress should not have their geolocation, routines, and mental health logs funneled into proprietary ad-targeting pipelines. Open models keep the pipeline transparent and self-hosted.
Zero Operating Toll: Closed APIs impose metering costs per token. By utilizing open-weight foundations, anyone in the community can host their own instance or community run club planner for zero ongoing API bills.

Prize Categories

Featured Category — Best Use of Render ($200): TrailPulse is containerized with Docker and hosted on Render's cloud platform as a fast, accessible AI runtime.
Featured Category — Best Use of Gemma ($200): The project relies on Google's Gemma 2 open-weight model as its creative core, turning raw location and time inputs into bite-sized sensory outdoor quests.

AllerGuard: Keeping My Roommate Safe in the Kitchen with Local Gemma 2

Aryan Mohan — Sun, 04 Oct 2026 14:35:25 +0000

This is a submission for theHacktoberfest Weekend Challenge: Build for a Friend

What I Built

Cooking with friends and roommates should be one of the best parts of living together. But when your roommate has severe food allergies, every meal prep turns into an anxious guessing game.

My roommate has a severe peanut allergy and a painful sensitivity to dairy and gluten. If you've ever tried scanning complex recipe cards, takeout descriptions, or ingredient lists after a long day of classes and work, you know how easy it is to miss hidden culprits:

Soy sauce often contains wheat/gluten.
Traditional pestos are loaded with pine nuts and parmesan cheese.
Worcestershire sauce typically includes anchovies.
Sauces and dressings frequently hide whey or dairy thickeners.

I built AllerGuard for my roommate: an intelligent culinary safety companion. You enter your friend's allergy profile, paste any recipe or meal kit text, and AllerGuard instantly:

Scans every ingredient for direct and hidden dietary hazards.
Explains why an ingredient is risky.
Recommends delicious, 1-to-1 safe substitutions (e.g. swapping heavy cream for oat cream, or standard soy sauce for tamari/coconut aminos).
Provides cross-contamination and kitchen prep advice.

When I showed it to my roommate and pasted their favorite pasta recipe, their reaction was immediate relief: "Wait, I never have to spend 15 minutes squinting at ingredient labels on my phone again?"

Demo

Video Link: Link

Key Features:

One-Click Profiles: Customize your friend's name and toggle known allergies (Peanuts, Gluten, Dairy, Soy, Shellfish, etc.) with custom tag additions.
Instant Ingredient Audits: Color-coded risk indicators (HIGH / MEDIUM / LOW) with plain-English rationales.
Pantry-Friendly Swaps: Thoughtful culinary substitutes that preserve the dish's flavor and texture without triggering allergic reactions.
Kitchen Safety Reminders: Practical tips on preventing cross-contamination during prep.

Code

Github Repository: https://github.com/AryanMohan818/AllerGuard

How I Built It

AllerGuard is designed from the ground up to be 100% containerized, local, and self-hosted:

┌────────────────────────────────────────────────────────┐
│               Docker Compose Architecture              │
│                                                        │
│  [ React Frontend ] ────► [ FastAPI Backend ]          │
│     (port 5173)                 │ (port 8000)          │
│                                 ▼                      │
│                         [ Ollama Container ]           │
│                            (port 11434)                │
│                                 │                      │
│                         [ Docker Volume ]              │
│                       (stores gemma2 model)            │
└────────────────────────────────────────────────────────┘

Why Does Open Innovation Matter?

When deciding how to build AllerGuard, using a closed, proprietary cloud LLM API (like OpenAI or Anthropic) was an option. However, open innovation was fundamentally better—and actually essential—for what I built:

Medical & Health Data Privacy:
Personal dietary restrictions and medical allergies are sensitive personal health information. With Google's open-weight Gemma 2 running locally inside our own Docker environment, zero health data ever leaves the laptop. No third-party servers, no corporate data retention policies, and no risk of personal dietary logs being fed into external training datasets.
Zero Operating Cost for Roommates:
College students and roommates shouldn't have to pay recurring monthly API token fees or subscription tiers just to cook dinner safely. Open-weight models democratize access: once downloaded, Gemma 2 costs exactly $0.00 to run indefinitely, completely eliminating API bill anxiety.
100% Offline Kitchen Reliability:
Whether you're cooking in an off-grid cabin, an apartment with spotty Wi-Fi, or camping without cell service, AllerGuard works without an internet connection. Open-source models turn consumer hardware into independent, reliable edge intelligence hubs.
Model Freedom & Deterministic Control:
Because Gemma 2 is open, we can pair it with local container runtimes like Ollama to enforce strict, constrained JSON decoding schemas. We don't have to worry about a closed provider deprecating a model endpoint, altering system prompts, or silently changing safety guardrails behind our backs.

My Agent Session

To build AllerGuard efficiently over the weekend, I paired with an autonomous coding agent (Antigravity) throughout the entire development lifecycle:

Iterative Architecture Design: We collaborated to architect a 100% containerized, multi-service setup (React + FastAPI + Ollama) rather than a monolithic local script, ensuring full reproducibility.
Prompt Engineering for Gemma 2: We designed and refined the culinary safety prompt to constrain Gemma 2's reasoning into strict JSON outputs with hazard categorization and culinary substitutions.
Fast Troubleshooting: During development, we diagnosed Linux container case-sensitivity issues (App.jsx resolution inside Alpine Node) and configured Docker internal networking (http://ollama:11434) seamlessly.

Using an agent as an interactive pair-programmer accelerated the process from initial brainstorm to a polished, fully Dockerized repository in just a few hours.

Prize Categories

🌟 Best Use of Gemma ($200)

AllerGuard uses Google's open-weight Gemma 2 (2B) as its core reasoning engine. Gemma 2 is deployed locally inside a dedicated Docker container via Ollama, parsing recipe ingredients, detecting hidden cross-reactive allergens, and generating structured JSON substitution recommendations with zero cloud dependencies.

DEV Community: Aryan Mohan

ZenSloth: An Offline-First Bedtime Companion Built for the Art of Doing Nothing

What I Built

Demo

Run Locally with Docker (One Command)

Code

AryanMohan818 / ZenSloth

Getting Started

Learn More

Deploy on Vercel

How I Built It

1. Local Open-Weight Inference with Ollama (qwen2.5:1.5b)

2. Pure Procedural Web Audio Engine

3. Next.js 16 + Tailwind CSS v4

Why Does Open Innovation Matter?

The Lazy Payoff

Prize Categories

Leadger Guard

What I Built

The Problem It Solves

Who Would Pay For It?

Code

How I Built It

Why Does Open Innovation Matter?

Prize Categories

TrailPulse: The Open-AI Outdoor Companion That Wants You to Close Your Screen

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

Prize Categories

AllerGuard: Keeping My Roommate Safe in the Kitchen with Local Gemma 2

What I Built

Demo

Key Features:

Code

How I Built It

Why Does Open Innovation Matter?

My Agent Session

Prize Categories

🌟 Best Use of Gemma ($200)

1. Local Open-Weight Inference with Ollama (`qwen2.5:1.5b`)