DEV Community: Manik garg

Simple yet effective AI power timesheet

Manik garg — Mon, 26 Oct 2026 03:13:09 +0000

---
title: "Auto Timesheet Desktop — Your AI-Powered Work Log That Writes Itself, Locally"
published: true
description: "A Windows desktop app that silently watches what you work on all day and uses a local Gemma LLM (via LM Studio) to generate a professional timesheet — no cloud, no subscriptions, no privacy trade-offs."
tags: hacktoberfest, python, ai, opensource

cover_image:

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

What I Built

Auto Timesheet Desktop is a Windows background agent that silently tracks everything you do on your computer all day — which apps you focus on, which Excel spreadsheets you edit, which web forms you submit, and which emails you send — then, at the end of the day, feeds those raw activity logs to a locally running Gemma LLM (via LM Studio) to generate a clean, structured, professional daily timesheet in seconds.

The person who gets to be lazier: Anyone who has to fill in a daily or weekly timesheet manually. Consultants, freelancers, corporate employees, finance teams — anyone who ends the day trying to remember what they actually worked on for the last 8 hours.

What it tracks automatically (zero manual effort):

🖥️ Active window focus — app name, document/tab title, and duration (with idle detection > 5 min)
📊 Excel & spreadsheet operations — detects when .xlsx, .xls, .csv, or .xlsm files are created, modified, renamed, or deleted in your watched folders
🌐 Web activity & form submissions — via a lightweight companion browser extension (Chrome/Edge), captures visited URLs and online form submissions (safely masking passwords and tokens)
📧 Sent emails — captures outgoing Gmail and Outlook Web emails with recipient and subject via the same browser extension
⏱️ Live activity feed — a real-time scrolling dashboard of every tracked event

What the Gemma LLM does with all this:

At end-of-day (manually triggered or scheduled), the app sends the raw .txt activity log to the local Gemma model with a carefully engineered prompt. Gemma reads the log and produces a structured JSON timesheet with:

Grouped work sessions by project and category (Development, Documentation & Excel, Communication & Email, Research & Web, Admin & Forms)
Realistic start/end times and duration per task
Specific artifacts: file names, URLs, email recipients
An executive summary of the day's work
Accurate category-level time breakdown

If LM Studio is offline, a smart heuristic fallback analyzer (no LLM required) parses the raw logs using timestamps and classifies every event into the same structured format.

Result: A fully filled-in, exportable timesheet that took zero manual effort.

Here's what the end-to-end flow looks like in a real session:

1. The app runs silently in the system tray all day.

Raw activity log captured for a real morning session:

[06:34:37] [WINDOW] chrome.exe | Gmail - Google Chrome | 3s
[06:37:01] [WINDOW] chrome.exe | Inbox (78) - Gmail | 144s
[06:39:09] [FILE_EXCEL] RENAMED_OR_MOVED | first book to write.xlsx
[06:40:59] [WINDOW] EXCEL.EXE | first book to write - Excel | 108s
[06:42:20] [WINDOW] chrome.exe | Untitled form - Google Forms | 18s
[06:45:59] [WINDOW] chrome.exe | ChatGPT | 54s
[06:48:53] [WINDOW] LM Studio.exe | LM Studio | 108s

2. Click "Generate Timesheet with Gemma" — done in ~15 seconds.

The Gemma model reads the log and returns:

{
  "date": "2026-10-26",
  "summary": "Morning session covered email review, spreadsheet editing (first book to write.xlsx), online form administration, AI research via ChatGPT, and local model setup in LM Studio.",
  "total_hours_tracked": 1.4,
  "entries": [
    { "project": "Email & Communications", "category": "Communication & Email",  "start_time": "06:34", "end_time": "06:38", "duration_minutes": 5 },
    { "project": "Spreadsheet Management", "category": "Documentation & Excel",  "start_time": "06:38", "end_time": "06:41", "duration_minutes": 12, "artifacts": ["first book to write.xlsx"] },
    { "project": "Web Operations & Forms", "category": "Admin & Forms",          "start_time": "06:41", "end_time": "06:43", "duration_minutes": 6 },
    { "project": "Online Research & AI",   "category": "Research & Web",         "start_time": "06:43", "end_time": "06:47", "duration_minutes": 5 },
    { "project": "Local AI & Model Setup", "category": "Development",            "start_time": "06:47", "end_time": "06:50", "duration_minutes": 15, "artifacts": ["LM Studio"] }
  ]
}

3. Export to Excel .xlsx, JSON, or copy a Markdown table — one click.

Code

🔗 GitHub: https://github.com/YOUR_USERNAME/Auto_time_sheet
(Replace with your actual repository URL before publishing)

Project Structure

Auto_time_sheet/
├── main.py                     # Entry point (GUI + headless + --analyze modes)
├── config.py                   # Settings manager
├── requirements.txt
├── tracker/
│   ├── activity_manager.py     # Orchestrates all trackers
│   ├── window_monitor.py       # Win32 API active window + idle detection
│   ├── file_monitor.py         # Watchdog-based Excel file event listener
│   ├── web_receiver.py         # HTTP server for browser extension events
│   └── logger.py               # Writes activity_YYYY-MM-DD.txt + .jsonl
├── analyzer/
│   ├── prompt_builder.py       # Packages raw logs for Gemma prompt
│   ├── gemma_client.py         # LM Studio OpenAI-compatible API client
│   └── json_parser.py          # JSON repair + smart heuristic fallback
├── ui/
│   ├── app.py                  # Main window
│   ├── timesheet_view.py       # Timesheet cards, category pills, export
│   ├── activity_view.py        # Real-time event stream feed
│   ├── settings_view.py        # LM Studio config, model auto-detect
│   └── tray_icon.py            # Windows system tray support
├── browser_extension/          # Manifest V3 Chrome/Edge extension
│   ├── manifest.json
│   ├── background.js
│   ├── content.js              # Captures forms + Gmail/Outlook sent
│   └── popup.html / popup.js
└── data/
    ├── logs/                   # activity_YYYY-MM-DD.txt (gitignored)
    ├── timesheets/             # timesheet_YYYY-MM-DD.json (gitignored)
    └── settings.example.json   # Template config for new users

Tech Stack

Layer	Technology
Language	Python 3.10+
GUI	CustomTkinter (dark mode, rounded cards)
Window tracking	Win32 API via `ctypes` / `pywin32`
File monitoring	`watchdog`
Browser integration	Chrome/Edge Manifest V3 Extension (JS)
LLM inference	Gemma 2 via LM Studio (local OpenAI-compatible API)
Fallback analysis	Custom rule-based heuristic log classifier
Export	`openpyxl` (Excel), JSON, Markdown clipboard
System tray	`pystray` + `Pillow`

How I Built It

The open-source AI at the core: Google Gemma 2 via LM Studio

The AI backbone is Gemma 2 — Google's open-weight language model family — running 100% locally through LM Studio, which exposes an OpenAI-compatible API endpoint at http://localhost:1234/v1.

No OpenAI account. No Anthropic subscription. No API key. Zero dollars spent on inference.

The key engineering challenge was prompt engineering for structured output. Gemma models don't natively support a separate system role in their chat template, so I pack system instructions and user task into one combined user message:

def build_combined_gemma_prompt(date_str, raw_log_text):
    """Single combined prompt — max compatibility with Gemma chat templates."""
    sys_prompt, user_prompt = build_gemma_prompt(date_str, raw_log_text)
    return f"{sys_prompt}\n\n========================================\nTASK:\n{user_prompt}"

The prompt carefully guards against common Gemma failure modes:

✅ Separate different activities — no merging email work with Excel work into one vague block
✅ Classify by window title keywords — Gmail/Inbox → Communication & Email, Google Forms → Admin & Forms, ChatGPT → Research & Web, Excel → Documentation & Excel
✅ Use real timestamps — the log has exact timestamped events; Gemma derives HH:MM start/end times from them

The smart fallback engine (no LLM needed)

Because LM Studio can be offline — or Gemma's JSON can be malformed — I built a complete standalone heuristic classifier (generate_fallback_timesheet() in json_parser.py):

Parses every timestamped log line with regex
Classifies every event (FILE_EXCEL, WINDOW, WEBMAIL_SENT, WEB_FORM, WEB_VISIT) via classify_event() — matching app names and window titles to work categories
Groups nearby same-category events into sessions (20-minute merge tolerance)
Calculates real start/end times and durations from actual log timestamps
Produces the identical JSON schema as Gemma

The parse_timesheet_json() repair layer handles trailing commas, unquoted keys, JS-style comments, and unescaped newlines before falling back to heuristics.

The browser extension

Web activity is captured via a Manifest V3 Chrome/Edge extension that:

Sends WEB_VISIT events after a 3-second delay on any page (skipping redirect flashes)
Intercepts submit events on <form> elements — collecting field identifiers only, explicitly excluding passwords and hidden inputs
Hooks into Gmail's Send button via aria-label attribute matching and Ctrl+Enter keystroke
Mirrors the same pattern for Outlook Web

Events are POST-ed to a local Python HTTP server (web_receiver.py, port 58432) running in a daemon thread inside the main app.

Why Does Open Innovation Matter?

A closed API would have killed this project before it started — not technically, but ethically.

Your daily activity log is deeply personal. It contains:

The exact URLs you browse
Subject lines and recipients of your emails
The filenames of every document you open and edit
Precisely how long you spent on every task

Sending that to a commercial cloud API means handing your full workday to a third party to store, process, and potentially train on. With GDPR, HIPAA, and NDA obligations in most professional environments, that is a non-starter for lawyers, accountants, healthcare administrators, consultants, and anyone working with confidential client data.

Open-weight local models like Gemma 2 make state-of-the-art structured reasoning available on a modest laptop with zero data leaving the machine. LM Studio democratizes that capability without requiring users to manage Python inference environments.

Open model + open inference runtime = privacy-preserving AI that is genuinely usable by people whose jobs require confidentiality. That's what made this project possible — and that's what a closed API never could have provided.

My Agent Session

(Optional — add your DevRelay session recording here with the agent_session tag, or remove this section)

The Lazy Payoff

I tested this on a real morning session (06:30–07:30) covering email, Excel, Google Forms, ChatGPT, and LM Studio:

	Manual	Auto Timesheet
Time to fill timesheet	~10 minutes	0 minutes
Timestamp accuracy	Guessed, rounded	Exact from log
Filenames captured	Whatever I remember	`first book to write.xlsx` automatically
Tasks missed	2–3 typically	0

Across a 5-day work week that's 50 minutes saved — and the quality is objectively higher because it captures exact timestamps and every task, including the ones you'd normally forget to log.

Prize Categories

🤖 Open-source AI — Built entirely around Google Gemma 2 (open-weight model, local inference via LM Studio)
🐍 Python — Core application built in Python 3.10+
🔒 Privacy-first AI — Zero cloud dependency; all activity data stays on-device

Installation

# 1. Clone the repo
git clone https://github.com/manik-dev-sudo/Auto_time_sheet.git
cd Auto_time_sheet

# 2. Install dependencies
pip install -r requirements.txt

# 3. Download LM Studio, load any Gemma model, click Start Server

# 4. Run
python main.py

See the full README for browser extension setup, CLI options (--headless, --analyze), and configuration details.

To-do on steroid

Manik garg — Sun, 18 Oct 2026 18:02:34 +0000

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

What I Built

To-Do on Steroids is an ultra-fast, voice-first AI Taskmaster built as an installable Progressive Web App (PWA). It transforms how busy professionals, solopreneurs, and developers interact with daily to-do lists by turning natural spoken speech into organized, scheduled, and categorized tasks with automated status tracking.

The Problem

Traditional to-do apps fail because of friction. Manually opening an app, typing task names, picking dates from calendar pickers, tagging categories, and hunting down checkboxes to click takes mental energy. As a result, busy people, freelancers, and individuals with ADHD often abandon their to-do apps within a week. Furthermore, most AI productivity tools force user data into centralized third-party clouds, making offline use and privacy difficult.

The Solution & Who Would Pay For It

With To-Do on Steroids, you simply hit the pulsing microphone and talk naturally:

"Hey, I just finished the client invoice and the quarterly roadmap review, and please schedule a sync with the design team today at 4:30 PM with high priority."

The app's AI Action Engine:

Semantically matches spoken accomplishments against your existing tasks (e.g., "finished client invoice" automatically matches and marks "Send September billing invoice to client").
Extracts new tasks, scheduled times (4:30 PM), priority levels, and category tags without any manual entry.
Presents an interactive Action Review modal showing a clean visual diff of what will be marked done and what will be created, allowing one-tap approval or instant inline edits.
Offline & Open-Weight Ready: Designed to work seamlessly with Gemma, Google's open-weight model family. When Gemma is hosted or stored offline on your local machine (e.g., via local inference servers or Ollama), the entire voice-to-task pipeline runs 100% locally and completely offline—no data ever leaves your device.
Applies dynamic animations, strikethrough styling, and auto-archives completed tasks.

Who would pay for it?

Privacy-conscious professionals & enterprise workers who cannot upload confidential company tasks to closed external APIs, and need local open-weight AI (Gemma) running on-premise or offline.
Freelancers & Solopreneurs juggling multiple projects who want to brain-dump their progress in 10 seconds between calls.
ADHD & Neurodivergent individuals who struggle with the cognitive load of traditional task managers.
Remote developers & agency owners tracking day-to-day work effortlessly.

A viable monetization model is a $5–$8/month subscription or a $29 lifetime deal for cloud sync/collaboration and managed Gemma model serving, while keeping the client-side app open-source for self-hosting with local Gemma models.

Demo

- 🌐 Live Application: [https://to-do-on-steroid-git-main-jodos-projects-58908ed7.vercel.app/]

Code

- 💻 GitHub Repository: [https://github.com/manik-dev-sudo/To-do_on_Steroid.git]

How I Built It

To-Do on Steroids is built with a focus on speed, local privacy, low latency, and zero bloat:

Frontend & Core Engine: Modern Vanilla JavaScript, semantic HTML5, and responsive custom CSS design system with glassmorphism, glowing neon accents, and smooth micro-interactions.
Real-Time Voice & Audio: Continuous speech recognition powered by the native browser Web Speech API, paired with an HTML5 Canvas real-time audio waveform visualizer and synthesized futuristic Web Audio API sound FX.
AI Processing Pipeline & Gemma Support:
- Open-Weight Gemma Model Integration: The system prompt and extraction pipeline are engineered to be model-agnostic. The structured JSON parser works out-of-the-box with Google's Gemma open-weight models (such as Gemma 2B, 9B, or 27B) served locally (via Ollama / local inference endpoints) or hosted through Google Cloud.
- 100% Offline Capability: Because the app is a Progressive Web App (PWA) with cached assets and local storage, pairing it with an offline-stored Gemma model allows you to manage tasks completely disconnected from the internet on airplanes, trains, or secure environments.
- Google Gemini Cloud Option: For users who prefer zero-setup cloud inference, the app also natively supports direct Google AI Studio API connections (gemini-2.5-flash, gemini-2.0-flash, gemini-1.5-flash) with automatic model discovery and diagnostics.
- Structured Action Schema: Translates messy conversational input into atomic task mutations: COMPLETE_TASK, ADD_TASK, and RESCHEDULE_TASK.
Progressive Web App (PWA):
- Fully offline-ready using a custom sw.js Service Worker and Web App Manifest (manifest.webmanifest).
- Native installation support in Google Chrome, Edge, and mobile browsers — installs as a standalone desktop app on Windows/macOS and mobile app on Android/iOS with custom neon icons.
Privacy-First Client-Side Storage:
- All tasks and credentials stay strictly on your device (localStorage). Zero external logging, zero tracking.

Why Does Open Innovation Matter?

Open innovation is what made building To-Do on Steroids possible in days rather than months:

The Power of Open-Weight Models (Gemma): Closed APIs trap users behind paywalls, usage quotas, and privacy risks. Google's release of the Gemma open-weight models allows developers to bring state-of-the-art intelligence directly to consumer hardware and edge devices. Users no longer have to compromise between AI assistance and absolute privacy.
True Offline Resilience: Closed APIs instantly break when you lose internet access. By combining open web standards (PWAs, Service Workers) with open-weight models like Gemma stored offline, applications become truly resilient and self-contained.
Permissionless Innovation: Open weights and open web standards empower independent creators and solo hackers to build production-grade side hustles without enterprise budgets or restrictive platform dependencies.

Prize Categories

Best Use of Gemma

Use Gemma, Google's open-weight model, in building your project: run it locally, fine-tune it, or serve it through Google Cloud or another provider.

FloraBotany

Manik garg — Fri, 09 Oct 2026 19:11:40 +0000

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

🌸 FloraBotany AI: Wild Flower Foraging, Vision Identification & Valuation Guild

What I Built

FloraBotany AI is an open-source, full-stack citizen-botany web application designed to encourage people to literally "Touch Grass" — stepping away from desks, heading outdoors into meadows, parks, and trails, capturing photos of wild flora, and receiving instant AI-powered botanical identification, rarity rankings, and market wage valuations.

How It Gets People Off the Screen and Into the World

Modern life keeps us trapped in screen-dominated routines. FloraBotany AI transforms outdoor time into a rewarding, educational expedition:

Real-World Botanical Scavenger Hunt: The app rewards users for venturing outside to hunt for real, living plants. You cannot build a collection from a desk — you must find flowers blooming in nature.
AI Field Botanist in Your Pocket: When you discover a bloom, take a photo with your smartphone or camera. Google Gemini Multimodal Vision inspects petal morphology, stamen structure, and floral health in real time.
Rarity Tiers & Wage Appraisal: Every flower is appraised into a Guild Rank:
- 🌟 Rank SSS (Mythic): Extreme wild rarities ($350 – $750+ valuation)
- 💎 Rank S (Legendary): Alpine & endangered species ($150 – $340 valuation)
- 🔮 Rank A (Epic): Sacred wetlands & rare wild blooms ($75 – $145 valuation)
- 🥇 Rank B (Rare): High-altitude & exotic wildflowers ($35 – $70 valuation)
- 🥈 Rank C (Uncommon): Fragrant garden & meadow flora ($18 – $34 valuation)
- 🥉 Rank D (Common): Hardy pioneer wildflowers ($5 – $17 valuation)
Collector Wage & Royal Herbarium Vault: Users claim their appraised flower wage into their personal Wage Bank, catalog the specimen in their digital Royal Herbarium, track discovery statistics, and generate official printable Botanical Guild Specimen Certificates.
Ethical Foraging Protocol: Every identified flower includes ethical foraging guidelines, medicinal/cultural applications, and conservation advice so nature remains protected.

Who Is It For?

Outdoor Explorers & Hikers: Turns standard trail walks into an interactive taxonomic quest.
Curious Families & Students: Teaches real scientific binomial nomenclature (Nelumbo nucifera, Leontopodium nivale, etc.) in an engaging, gamified format.
Gardeners & Plant Parents: Instant health appraisal, bloom condition assessment, and preservation tips.
Botanical Enthusiasts & Collectors: Celebrates real-world biodiversity and conservation.

Demo

Live Deployed App on Vercel: https://florabotnay.vercel.app
GitHub Repository: https://github.com/manik-dev-sudo/florabotnay
Interactive Quick-Test Specimens: The app features a built-in specimen launcher showcasing high-resolution specimens (Ghost Orchid, Sacred Blue Lotus, Alpine Edelweiss, Royal Damask Rose, Golden Sunflower) for instant testing.

Key Workflows

Snap or Upload: Select or take a picture of a flower found outside.
Laser Vision Scan: Watch the holographic laser analyzer review petal geometry.
Appraisal Card: Discover the Latin genus, botanical family, freshness grade, rarity score (0–100), and itemized wage payout.
Deposit & Collect: Claim your wage to the Wage Bank and log the entry into your personal Herbarium.

Code

The project is built as a production-ready, full-stack application deployed on Vercel:

GitHub Repository: https://github.com/manik-dev-sudo/florabotnay

florabotnay/
├── api/
│   └── identify.js     # Vercel Serverless Function (Secure Gemini Vision backend API)
├── css/
│   └── styles.css      # Custom Obsidian & Emerald glassmorphism design system
├── js/
│   ├── app.js          # Audio synthesizer, confetti engine, camera, and collection state
│   ├── gemini.js       # Client API connector to /api/identify
│   └── data.js         # Curated specimens, rank tier algorithms, & fallback taxonomy
├── index.html          # Semantic HTML5 UI, upload studio, appraisal view & herbarium
├── vercel.json         # Vercel routing configuration
├── server.js           # Zero-dependency local Node.js static & API HTTP server
├── package.json        # Project metadata
└── README.md           # Quickstart and setup guide

Backend Architecture: Secure Serverless Vercel Function

The frontend does not expose any API keys. Instead, the client sends image data to /api/identify, which executes in a secure Vercel Serverless environment:

// Excerpt from api/identify.js (Vercel Serverless Function)
module.exports = async function handler(req, res) {
  const { image, mimeType } = req.body;
  const apiKey = process.env.GEMINI_API_KEY;

  const response = await fetch(
    `https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=${apiKey}`,
    {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        contents: [{
          parts: [
            { text: promptText },
            { inline_data: { mime_type: mimeType, data: base64Data } }
          ]
        }],
        generationConfig: { temperature: 0.2, maxOutputTokens: 1024 }
      })
    }
  );

  const data = await response.json();
  // Parse and calculate rank tiers and wage breakdown on backend...
  res.status(200).json(appraisalResult);
};

How I Built It

Secure Serverless AI Architecture:
- Deployed on Vercel with dedicated Serverless Functions in /api/identify.
- Utilizes Google's Gemini 1.5 Flash and Gemini 2.0 Flash models for fast, multimodal vision image understanding.
- API keys are managed securely as environment variables on the backend, ensuring zero credential exposure on the frontend.
Offline & Remote Trail Resilience:
- Hikers and foragers often explore remote trails without strong cellular service. FloraBotany AI incorporates an intelligent botanical taxonomic fallback engine so the app never hangs or crashes even with zero connection.
Pure Vanilla Web Stack (Zero-Bloat):
- Vanilla CSS3: Engineered from scratch with custom CSS variables, glassmorphic backdrop filters, dynamic holographic rank badges, and responsive layouts without bloated external frameworks.
- Web Audio API: Built an in-browser procedural sound synthesizer that generates discovery chimes, high-rank fanfares, and cash-register coin chimes without requiring heavy audio assets.
- Canvas Confetti: Lightweight particle physics engine to celebrate high-rank floral discoveries.
Privacy-First & Local Storage:
- The user's herbarium is preserved directly in localStorage. Images and personal discovery logs stay on the user's device, with 1-click JSON export and printable physical certificate modes.

Why Does Open Innovation Matter?

Open innovation is essential when connecting technology with the physical environment:

Democratizing Natural Literacy: Botanical and ecological knowledge shouldn't be locked behind paywalls or proprietary walled gardens. Open-source AI tools empower citizen scientists, park rangers, and amateur botanists everywhere.
Auditability & Conservation: In foraging, accuracy and ethical harvesting matter. Open-source prompts and code allow naturalists to inspect the model's instructions, verify that protected endangered species aren't marked for destructive harvesting, and promote ecological stewardship.
Zero Barrier to Entry: By using open web standards and client-side execution, anyone with an inexpensive smartphone and a browser can take this app onto the trail without installing proprietary app store packages.

My Agent Session

This project was built end-to-end with the Google Antigravity agentic coding assistant:

Full-stack architecture with Vercel serverless functions and Google Gemini Multimodal Vision.
Pure vanilla CSS glassmorphism design and procedural Web Audio synthesizer.
Resilient fallback handling ensuring 100% uptime for outdoor foragers.

Prize Categories

Grand Prize / Best Overall
Touch Grass (Most Compelling Real-World / Outdoor Application)
Best Use of Multimodal AI / Computer Vision
Best Educational / Citizen Science Application

Health Diary

Manik garg — Sun, 04 Oct 2026 17:27:40 +0000

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

What I Built

I built Health Diary — an effortless, privacy-first nutrition and calorie tracking web app designed for my friend who wanted to eat healthier and track their meals without the tedious manual searching, complex ingredient lookups, or paid subscription paywalls found in most mainstream fitness apps.

The Problem It Solves

Traditional calorie trackers require you to search through cluttered databases for every single ingredient, guess serving sizes in obscure units, and spend 5–10 minutes after every meal tapping through endless dropdowns. My friend found this friction so exhausting that they constantly abandoned tracking after just a couple of days.

The Solution

With Health Diary, logging a meal takes 5 seconds:

Speak or Type Naturally: You simply tap the mic or type in plain language: "2 boiled eggs, a slice of whole wheat toast with peanut butter, and a black coffee for breakfast".
Smart Nutrition Parsing: The built-in parsing engine automatically extracts the food items, calculates portion quantities (fractions, units, grams, cups, slices), determines the meal time, and scales all nutritional components instantly.
Deep Component Analysis: Beyond just counting calories, it provides a comprehensive breakdown of Macronutrients (Protein, Carbs, Fat) and Micronutrients (Dietary Fiber, Sugar limit, Sodium, Potassium, Calcium, Iron, Vitamins) with an algorithmic Diet Quality Score.
Monthly Insights & Calendar: An interactive calendar and daily calorie trend chart allow inspecting any historical date with one click, tracking consistency, and exporting data as CSV.

Demo

Live App Demo: https://healthdiary-zeta.vercel.app/
Video / Screenshots Preview:
- 🎙️ Home & Voice Logging: Tap to speak or type meals, review live calorie rings, macro bars, and hydration.
- 📊 Daily Analysis: In-depth macronutrient donuts, micronutrient meters, and full food item tables.
- 🗓️ Monthly Calendar: Color-coded compliance overview with click-to-inspect daily explorer.

Code

The complete source code is available on GitHub:

manik-dev-sudo / Nutrition_tracker

Nutrition tracker that keep track of your nutrition requirement throughout the day

Health Diary

A simple calorie and nutrition tracker designed to make logging meals effortless. Instead of searching and adding ingredients one by one, you can just speak or type what you ate in plain language (e.g., "2 boiled eggs, a slice of whole wheat toast with peanut butter, and a cup of black coffee"), and the app calculates the calories and nutrition breakdown for you.

How It Works

1. Home & Quick Logging (Speak or Type)

Voice or Text Input: Tap the microphone button to speak or type what you ate in your own words.
Smart Food Parser: Automatically understands quantities, portions, fractions, and meal types (Breakfast, Lunch, Dinner, Snack).
Confirmation Preview: Lets you quickly review items, adjust portions with + / - buttons, or remove items before adding them to your log.
Today's Summary: Live calorie ring (calories eaten vs. your daily target), progress…

View on GitHub

How I Built It

Health Diary was built with a zero-dependency, ultra-fast, offline-first vanilla web stack:

Frontend Architecture: Built using semantic HTML5, modern Vanilla CSS with a crisp light wellness aesthetic (Plus Jakarta Sans typography, soft gradients, responsive glass cards), and modular JavaScript (ES Modules).
Speech Recognition (Web Speech API): Native speech-to-text integration that transcribes natural voice descriptions in real-time with zero external server latency.
Natural Language Food & Nutrition Parser:
- Built-in comprehensive food database spanning 150+ standardized foods across all food groups (Proteins, Carbs, Dairy, Vegetables, Fruits, Snacks, Dishes).
- Rule-based natural language parser that detects multi-item lists, fractions (1/2, 1.5), units (tbsp, g, cups, bowls, pieces), and meal keywords (for breakfast, in lunch, as a snack).
Interactive SVG Charting Engine: Custom, lightweight SVG engine that renders responsive calorie progress rings, macronutrient ratio donuts, and monthly trend bar charts with interactive hover states and click-to-inspect event bindings.
Local Storage & Privacy: All logs, hydration metrics, and custom foods are stored strictly on the user's device (localStorage), guaranteeing 100% privacy with zero tracking or mandatory account sign-ups.

Why Does Open Innovation Matter?

Open innovation enables us to build tools that prioritize the user over data monetization.

Most commercial diet apps lock basic nutritional breakdowns (like fiber, sodium, and micronutrient ratios) behind expensive monthly paywalls, while collecting personal health data for advertising.

By building an open-source, client-side application:

Health is Accessible to Everyone: Clean, accurate nutrition tracking without ads, paywalls, or forced subscriptions.
True Data Sovereignty: Personal dietary logs remain entirely on the user's browser, accessible offline anytime.
Extensibility: Anyone can fork the project, add localized food databases for their region, or customize their nutritional targets.

My Agent Session

This project was built with the assistance of agentic AI workflows. The agent assisted in designing the natural language parser regex rules, standardizing the USDA nutrition database components, architecting the interactive SVG visualization engine, and crafting the clean wellness design system.

Prize Categories

Build for a Friend
Open-source Web Application