DEV Community: dev bansal

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

dev bansal — Thu, 29 Oct 2026 08:19:38 +0000

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

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 🦥

dev bansal — Sat, 24 Oct 2026 08:28:41 +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 💸

dev bansal — Thu, 15 Oct 2026 16:52:11 +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.

WildLens 🌿 — Where AI Meets the Wild

dev bansal — Sun, 11 Oct 2026 11:25:37 +0000

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

What I Built

WildLens — AI Nature Identifier 🌿

WildLens is a nature exploration prototype designed to help people disconnect from their screens and reconnect with the natural world.

The idea behind WildLens is simple: instead of spending hours scrolling, people can go outside, discover plants, birds, insects, and trees, and use technology to learn more about what they find.

The prototype focuses on making nature exploration interactive and educational through:

Nature Identification: Explore the idea of identifying natural objects through photographs.
Nature Discovery: Learn interesting facts about the natural world.
Nature Missions: Encourage outdoor exploration through real-world challenges.
Nature Journal: Keep a record of personal discoveries.
Digital Wellness: Turn technology into a tool for exploring the outdoors.

WildLens is designed for students, nature enthusiasts, and curious people who want to learn about their surroundings.

My goal is to build an experience that encourages people to spend less time passively scrolling and more time discovering the world around them.

Demo

Try the WildLens prototype here:

Open WildLens Live Demo

Code

Explore the source code and project development on GitHub:

WildLens GitHub Repository

How I Built It

I built WildLens as a web-based prototype, focusing on creating an engaging interface for nature exploration and learning.

The concept combines a digital nature-discovery experience with the potential of AI-assisted identification. The intended user journey is straightforward: discover something outdoors, capture its photograph, learn about it, and record the experience.

I am also interested in exploring open-source computer vision models and local inference to make nature identification more flexible and reduce dependence on closed AI APIs.

The project is an ongoing learning experience for me as a computer science student interested in AI and machine learning. My focus is on improving the experience, exploring suitable open-source technologies, and making the prototype more useful for real-world nature exploration.

Why Does Open Innovation Matter?

Open innovation gives developers the freedom to experiment, collaborate, and build solutions that can grow beyond their original creators.

For WildLens, open-source AI offers opportunities to explore different vision models, learn how AI systems work, and potentially support local inference instead of depending entirely on proprietary APIs.

It also creates opportunities for other developers to contribute ideas, improve the project, and help make nature education more accessible.

As a student developer, I believe open source is one of the best ways to learn by building real projects, share knowledge, and turn ideas into something useful for the community.

My Agent Session

I am exploring AI-assisted development as part of my journey building WildLens.

DevRelay agent session: Not included yet. I will add a shareable session link if available.

Final Thoughts

WildLens is my attempt to build something that combines AI, learning, and outdoor exploration.

As a computer science student interested in AI and machine learning, I want to keep improving the prototype, learn from community feedback, and explore how open-source AI can make nature education more accessible.

The goal is simple: less passive scrolling, more real-world discovery.

DEV Community: dev bansal

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

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 💸

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

My Agent Session

WildLens 🌿 — Where AI Meets the Wild

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

My Agent Session

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