DEV Community: Dhruv Singla

NecroLog: The Haunted Daemon — Air-Gapped Systems Telemetry & Process Archaeology

Dhruv Singla — Wed, 28 Oct 2026 16:19:13 +0000

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

What I Built

NecroLog is an institutional, air-gapped system observability dashboard that brings literal meaning to the theme Ghost in the Machine.

In modern computing, operating systems are inherently steeped in spectral nomenclature: daemons running quietly in the background, zombie processes that have terminated but still linger in the process table, and orphan routines severed from their parent PID.

NecroLog interrogates this low-level systems layer using real hardware telemetry. It inspects lingering background processes, hung PIDs, anomalous thread allocations, and memory pressure, piping them directly to an on-device open-weight model. Acting as a digital archaeologist, the model performs a technical and poetic "post-mortem" on the operating system's state—diagnosing the digital echoes, abandoned threads, and legacy routines that are silently haunting your machine.

It bridges low-level POSIX systems engineering with local open-weight AI inference, packaged inside a refined, enterprise dark-mode console.

Demo

Live Web Console (Vercel Preview): https://necro-log.vercel.app

Code

Direct Repository Link: https://github.com/ziyadparkar01/NecroLog

How I Built It

NecroLog relies strictly on a lightweight, multi-language architecture that enforces a clean separation of concerns while avoiding heavy, bloated JavaScript toolchains:

Local Inference Engine & Open Weights: Powered locally by Ollama running Llama 3.2 3B Instruct (with interchangeable support for Qwen 2.5 3B / 7B). The model consumes structured telemetry vectors and is conditioned through an analytical system prompt to act as an OS diagnostician and digital archaeologist.
Backend (Python 3.11+ / FastAPI): Architected as a single serverless-ready Python service (api/index.py). It utilizes psutil to inspect real-time process tables, memory swap pressure, active daemon hierarchies, and zombie states, dispatching asynchronous requests to Ollama over local HTTP via httpx.
Frontend (Vanilla ES6+ JavaScript, HTML5, CSS3): Strictly zero TypeScript, React, or Node bundlers. The user interface lives entirely in public/ and implements an enterprise-grade dark telemetry console featuring charcoal surfaces, hairline grid borders, monospace telemetry HUDs, and real-time process indicators.
Deployment & Portability: Packaged with a native vercel.json configuration for one-click serverless function routing, providing immediate cloud preview capabilities alongside local bare-metal execution.

necro-log/
├── api/
│   └── index.py            # FastAPI telemetry harvester + Ollama client + failover
├── public/
│   ├── index.html          # Enterprise dark-mode telemetry dashboard
│   ├── style.css           # Institutional design system (Inter + JetBrains Mono)
│   └── app.js              # Pure Vanilla ES6 state coordinator
├── requirements.txt        # Production Python dependencies (fastapi, psutil, httpx)
├── vercel.json             # Serverless routing & rewrites
└── README.md               # Architecture documentation & setup guide

Why Does Open Innovation Matter?
Open innovation is not just an aesthetic choice for NecroLog—it is the only architecture that makes the project viable:
Zero Data Exfiltration for Sensitive OS Telemetry: A computer's process list contains environment variables, absolute local file system paths, application flags, user IDs, and occasionally active authentication tokens. Piping an operating system's raw process table and daemon metadata to third-party commercial cloud APIs constitutes a critical security and privacy hazard. Running open weights locally guarantees that system vitals never leave the device.
True Air-Gapped, Offline Reliability: Closed models require continuous, high-bandwidth internet connectivity. An OS health monitor must operate when the network goes down, during an air-gapped incident response, or in low-connectivity environments with the lights and Wi-Fi completely cut. Local open-weight inference executes on-device with zero network latency.
Economic Feasibility for Ambient Daemons: A background utility continuously monitoring telemetry cannot sustain the per-token pricing of commercial cloud APIs without racking up steep, recurring bills. Open-source models turn continuous background intelligence into a zero-marginal-cost feature of the local hardware.

The Spirit of It
There is an eerie realization that occurs when you execute an inspection on a laptop that has been running uninterrupted for months. You uncover abandoned worker threads spawned by forgotten Docker containers, zombie parent processes from long-closed terminal windows, and cached background routines silently consuming memory in the dark.
Seeing an open-weight model parse through genuine hung PIDs and synthesize the lineage of forgotten compute turns everyday debugging into a profound encounter with the invisible, lingering history built into our machines.

SlothRead: Too Lazy to Read 40-Page Papers? Let Local AI Build Your Executive Deck 🦥

Dhruv Singla — Wed, 21 Oct 2026 15:37:08 +0000

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

What I Built

I built SlothRead, a privacy-first, offline executive synthesizer for EPUB books and dense research PDFs.

Between 40-page arXiv whitepapers, technical documentation, and long-form e-books, reading backlogs constantly pile up. In the spirit of International Sloth Day, SlothRead rewards digital laziness by automating the cognitive heavy lifting.

Instead of forcing you to skim dry prose and suffer cognitive burnout, you simply drop a PDF or EPUB into SlothRead. Running a local open-weight model completely on your machine, it distills the entire piece into a sleek, dark-mode Executive Presentation Deck featuring:

3 Non-Negotiable Core Takeaways per chapter.
An Interactive Technical Glossary explaining domain jargon upon hover.
A 60-Second Audio Recap generated completely offline using your browser's native Web Speech synthesis.
A Global Executive Brief detailing the core thesis and the exact reading time saved.

Researchers, developers, and students can conserve their energy like a sloth and digest complex documents in under 2 minutes.

Demo

Experience the live app or inspect the hosted instances directly:

Frontend Interface (Vercel): https://slot-read-ewx9.vercel.app

Code

Repository Link: https://github.com/ziyadparkar01/SlotRead

Repository Architecture

/backend: FastAPI service handling section/chapter chunking with PyPDF and EbookLib, alongside async Ollama inference pipelines.
/frontend: Decoupled vanilla HTML5/ES6/CSS interface featuring glassmorphic editorial cards, responsive chapter navigation, and a reactive 3D canvas background built with Three.js.

How I Built It

SlothRead is built entirely around an open-source, local-first inference architecture:

1. Local Open-Weight Inference Engine

Inference runs locally via Ollama using Google's Gemma 2 (gemma2:2b) or Qwen 2.5 (qwen2.5:3b).
Configured with native JSON mode (format: "json") paired with strict schema enforcement to guarantee consistent, structured outputs across chapter summaries, glossary terms, and narration scripts.

2. Document Parsing & Chunking Engine (`backend/app/parser.py`)

Built on pypdf, ebooklib, and beautifulsoup4.
Analyzes headings, chapter markers, and document hierarchies to extract coherent, meaningful narrative sections rather than relying on naive token splits that cut sentences mid-thought.

3. Decoupled Modern Frontend

Pure Vanilla ES6+ JavaScript — zero heavy framework dependencies or TypeScript compilation overhead.
Designed with an editorial aesthetic using Cabinet Grotesk, Newsreader serif typography, and JetBrains Mono.
Features an interactive 3D particle background rendered using Three.js that responds smoothly to mouse parallax and scroll position.

Why Does Open Innovation Matter?

Open innovation is not just an optional detail for SlothRead; it is the fundamental reason the project can exist safely:

Uncompromised Document & IP Privacy: Research papers often contain unreleased patents, proprietary company methodologies, or confidential legal and financial documents. Uploading these files to closed, centralized cloud APIs introduces serious data leakage risks. By running local open weights, confidential files never leave the host machine.
$0 Infinite Inference: Passing a 300-page book through commercial cloud endpoints racks up heavy token bills and frequently crashes against API context caps. Open-weight models running on consumer hardware cost absolutely nothing to run.
True Offline Independence: Whether you are commuting on a train, sitting on an airplane with no Wi-Fi, or working behind an air-gapped corporate firewall, SlothRead operates 100% offline without requiring an external internet connection.

The Lazy Payoff

During testing, I fed SlothRead a dense 38-page research whitepaper on distributed consensus mechanisms.

Traditional reading time: ~45–60 minutes of manual reading, skimming, and note-taking.
The SlothRead workflow: 1 drag-and-drop, ~40 seconds of background local processing on my laptop, and a crisp 4-slide executive presentation deck.
Total effort: 2 clicks. I stepped away, hit "60s Listen" on the executive summary, and walked away with every critical takeaway and term defined. *

PaperTrail: Your Private Financial Co-Pilot Powered by Open-Weight AI 💸

Dhruv Singla — Thu, 15 Oct 2026 16:38:23 +0000

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

## What I Built

PaperTrail — Your Private Financial Co-Pilot 💸

PaperTrail is a privacy-first financial document manager designed for freelancers, solopreneurs, and independent creators.

It uses open-weight multimodal AI to extract information from invoices and receipts, while a deterministic audit engine checks arithmetic discrepancies before records are exported.

Key features include:

🧠 AI-Powered **Extraction:** Turn receipts and invoices into structured financial records.
🔐 Privacy-First Architecture: Local-first storage and local inference options for sensitive financial data.
🛡️ Smart Audit Desk: Detect mismatched totals and flag errors for review with Nib, your AI audit companion.
💰 Tax Intelligence: Estimate tax offsets, track potential ITC/VAT, and generate reimbursement statements.
📊 CA-Ready Exports: Organize records into CSV ledgers, printable schedules, and local backups.
📱 Offline-First Design: Access locally stored records and cached application features offline, where supported.

PaperTrail helps freelancers spend less time on bookkeeping and more time growing their businesses.

## Demo

Live Demo: https://paper-trail-2pk6.vercel.app

Explore the General Ledger, Variance Resolution Desk, Tax Intelligence Engine, AI Benchmark Studio, and offline capabilities.

## Code

GitHub Repository: https://github.com/ziyadparkar01/Paper-Trail

Tech Stack: React 19, TypeScript, Vite, Tailwind CSS, Dexie.js, IndexedDB, Python FastAPI, and SQLite.

## How I Built It

PaperTrail combines open-weight AI with deterministic financial verification.

AI Models: Meta Llama 3.2 Vision and Qwen2.5-VL for local document-understanding workflows.
Local Inference: Ollama and FastAPI integration options for running models locally.
Audit Engine: TypeScript validation rules check extracted totals and flag discrepancies.
Storage: Dexie.js and IndexedDB support local-first financial record management.
Offline Support: Progressive Web App techniques help make cached application features accessible without a connection.

The key design decision is separating AI extraction from financial verification: AI interprets documents, while deterministic code checks the arithmetic.

## Why Does Open Innovation Matter?

Financial documents contain sensitive information, including client billing rates, bank details, and tax identifiers.

Open-weight AI makes local inference and greater control over document processing possible without depending entirely on closed cloud AI APIs.

It also enables developers to customize extraction workflows for regional invoice formats, reduce recurring inference costs, and build more transparent financial tools.

The goal: your financial data, your rules, your control.

## My Agent Session

Built using the AI Studio engineering environment, with a focus on:

Integrating open-weight document-understanding models.
Designing a deterministic financial audit engine.
Building a clean, responsive financial dashboard.
Implementing local-first storage and offline-oriented functionality.

🌿 TouchGrass AI — Less Scrolling. More Exploring.

Dhruv Singla — Sun, 11 Oct 2026 12:56:46 +0000

What I Built

TouchGrass AI is an AI-powered outdoor adventure companion designed to help people spend less time scrolling and more time exploring the real world.

In a world where we spend hours staring at screens, TouchGrass AI turns the simple idea of going outside into an engaging, personalized adventure.

Instead of endlessly browsing for things to do, users can discover outdoor missions based on their interests, available time, preferred difficulty, and surroundings. Whether it's exploring a nearby park, noticing birds and plants, discovering something new in the neighborhood, or simply taking a mindful walk, the goal is to make going outside more fun and rewarding.

🌱 What makes TouchGrass AI special?

Personalized outdoor missions: Turn your interests and available time into an outdoor adventure.

Real-world exploration: Encourage users to observe their surroundings, discover nature, and engage with the world around them.

Voice-assisted companionship: Make outdoor quests more engaging with a hands-free conversational experience, where supported by the current implementation.

A screen-free mindset: The app helps users prepare for their quest and then focus on the experience rather than remaining glued to their phones.

Privacy-conscious AI vision: The project aims to make open-weight AI a meaningful part of the experience, with local inference and offline-friendly behavior as key design goals.

The mission is simple: use AI to help people spend less time using AI-powered screens and more time experiencing the world.

Demo

🌐 Try TouchGrass AI: https://touch-grass-ai-one.vercel.app/

Open the prototype, explore the experience, and imagine your next outdoor quest!

Code

💻 GitHub Repository: https://github.com/dhruvsingla24/TouchGrassAI

The repository contains the project's source code and implementation details.

Before submitting, replace this placeholder with your actual public repository link.

How I Built It

I built TouchGrass AI as a mobile-first web experience, focusing on an engaging interface and a practical user journey rather than just another AI chatbot or landing page.

The core experience is designed around a simple flow:

Choose your adventure: Select your interests, available time, and preferred challenge level.

Generate a mission: Use AI to create an outdoor activity tailored to the user's preferences.

Go outside: Begin the quest and minimize unnecessary screen interaction.

Discover and reflect: Return to record observations, discoveries, and memorable moments from the experience.

The project is designed to bring open-source AI into a real-world use case where the technology supports the experience instead of becoming the experience itself.

My development priorities include:

A responsive, mobile-first interface.

Personalized mission generation.

A simple, distraction-free quest workflow.

Voice interaction to make adventures more engaging, where implemented.

An architecture that can support open-weight models, local inference, and offline-friendly functionality.

Open-source AI approach: The goal is to use open-weight AI models and open-source tooling to power the mission-generation experience, with a focus on making the system transparent, adaptable, and privacy-conscious.

Implementation note: Add the exact model name, inference runtime, and framework used in your working build before publishing this section. Only claim local inference, offline support, or a working voice assistant if you have verified those features in the deployed version or repository.

Why Does Open Innovation Matter?

Open innovation matters because AI should not be limited to closed platforms, proprietary APIs, or systems that users cannot inspect or adapt.

*For TouchGrass AI, open-source AI creates opportunities to:
*
Experiment freely: Customize how outdoor missions are generated for different users and environments.

Build with transparency: Make the model and supporting implementation easier for other developers to inspect and improve.

Explore privacy-first experiences: Investigate local inference so personal preferences and interactions can remain on the user's device where feasible.

Reduce dependency on closed services: Build toward an experience that can work with fewer external API dependencies.

Enable community contributions: Allow developers to improve mission generation, accessibility, voice interaction, and offline capabilities.

The interesting part is the contrast: we're using AI to encourage people to put their phones down.

Open innovation makes it possible to experiment with that idea in a way that other developers can understand, extend, and build upon.

🌿 TouchGrass AI — Less scrolling. More exploring.

Thanks for checking out my project! Feedback, ideas, and contributions are welcome.

From Beginner to Builder: My Coding Journey Begins

Dhruv Singla — Fri, 09 Oct 2026 04:28:53 +0000

Hello, Dev Community! I'm starting my developer journey

Hey everyone!

I'm a first-year B.Tech CSE (AI & ML) student, and I'm excited to start sharing my learning journey here.

Currently, I'm focusing on:

Java — learning programming fundamentals and building problem-solving skills.

HTML & CSS — exploring web development and learning how to build websites.

AI & Machine Learning — exploring the field and discovering what I can create with it.

I'm still a beginner, and I know there's a lot to learn. My goal is to stay consistent, build real projects, learn from my mistakes, and connect with people who share similar interests.

I'd love to hear from you!

What advice would you give someone just starting their developer journey?

Let's learn and grow together! 🤝

DevCommunity #100DaysOfCode #Java #WebDevelopment #AIandML

DEV Community: Dhruv Singla

NecroLog: The Haunted Daemon — Air-Gapped Systems Telemetry & Process Archaeology

What I Built

Demo

Code

How I Built It

SlothRead: Too Lazy to Read 40-Page Papers? Let Local AI Build Your Executive Deck 🦥

What I Built

Demo

Code

Repository Architecture

How I Built It

1. Local Open-Weight Inference Engine

2. Document Parsing & Chunking Engine (backend/app/parser.py)

3. Decoupled Modern Frontend

Why Does Open Innovation Matter?

The Lazy Payoff

PaperTrail: Your Private Financial Co-Pilot Powered by Open-Weight AI 💸

🌿 TouchGrass AI — Less Scrolling. More Exploring.

From Beginner to Builder: My Coding Journey Begins

DevCommunity #100DaysOfCode #Java #WebDevelopment #AIandML

2. Document Parsing & Chunking Engine (`backend/app/parser.py`)