DEV Community: Ziyad Parkar

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

Ziyad Parkar — Mon, 26 Oct 2026 20:46:51 +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 🦥

Ziyad Parkar — Tue, 20 Oct 2026 07:24:18 +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 💸

Ziyad Parkar — Thu, 15 Oct 2026 16:17:18 +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.

EchoQuest: Turn the Real World into Your RPG 🗺️🌿 #hf26challenge #devchallenge #openweights #touchgrass

Ziyad Parkar — Sun, 11 Oct 2026 13:49:16 +0000

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

EchoQuest is an outdoor adventure web app that gamifies real-world exploration to get people off their screens and into nature. Players customize their field ranger avatar, activate GPS tracking, and receive procedural quests like the Canopy Crafting Quest. With "Pocket Mode" enabled, users explore completely eyes-up: spatial audio and voice prompts guide them to physical landmarks. When an item is found, integrated camera vision leverages open-weight multimodal models to identify and validate specimens, granting XP and journal stickers—all running efficiently with complete data privacy.

🎵 I love assigning a theme song to my builds, just because it's fun. This one is "The Distance" by Cake, because it's all about going the extra mile outdoors!

Links & Demo
Live Demo: https://eco-quest1-dpor.vercel.app
GitHub Repository: https://github.com/ziyadparkar01/EcoQuest

What I Built
The idea for EchoQuest came from wanting an outdoor experience that doesn't feel like staring at a mobile game map while walking into a tree.

EchoQuest turns any park, hiking trail, or neighborhood walk into an interactive role-playing scavenger hunt.

Avatar Customization & Quest Generation: Players set up their ranger profile and receive context-aware, procedural outdoor missions based on their real-world surroundings.

Pocket Mode (Eyes-Up Exploration): Instead of staring down at a screen, players lock their device into Pocket Mode. Conversational voice prompts and spatial audio from our AI companion, Aura, guide them toward physical waypoints.

Specimen Validation: When players find a target object (like a specific leaf texture or rock formation), the built-in camera uses open-weight vision pipelines to identify and validate the discovery. Successful finds unlock 3D bio-cards and journal stickers.

Why Open Innovation Matters for This Project?
Building an app meant for the deep outdoors meant designing for environments with zero cloud connectivity and strict privacy needs:

True Offline & Edge Capabilities: By leveraging open-weight models and local execution pipelines, EchoQuest processes telemetry and voice cues even when deep on a remote hiking trail with zero cellular signal.

Complete Data Sovereignty: Users' exact GPS routes, favorite hiking spots, and personal nature photos stay private on their own devices—never streamed or stored on centralized commercial servers.

Fine-Tuning & Customization: Running open-source frameworks allowed us to customize Aura's voice companion behavior specifically for ambient outdoor interaction rather than generic assistant tasks.

Zero Cost at Scale: No per-token API bottlenecks or runaway cloud costs while players spend hours exploring.

Architecture & Tech Stack
AI & Vision: Open-weight audio/vision pipelines and multimodal open models for local telemetry and plant/wildlife validation.

Core Framework: Full-stack mobile-responsive architecture with real-time GPS telemetry and spatial audio support.

Agent Harness: Custom open-source agent loop powering Aura and procedural quest logic.

Here is a peek at how the procedural outdoor mission engine structures real-world coordinates:

Python
class EchoQuestEngine:
def init(self, ranger_profile):
self.ranger = ranger_profile
self.active_quest = None

def generate_outdoor_mission(self, user_location, terrain_type="forest"):
    print(f"🌲 Scanning local terrain near {user_location}...")
    self.active_quest = {
        "title": "The Canopy Crafting Quest",
        "objective": "Locate a unique leaf or bark texture and verify via camera.",
        "reward_xp": 150
    }
    return self.active_quest

Field Test & Results
We tested EchoQuest on local wooded park loops and open trails. By toggling Pocket Mode, players kept their eyes on the trees, birds, and paths rather than staring downward. The transition from digital audio clue to physical discovery was seamless, proving that AI can successfully bridge the gap between digital engagement and real-world touch-grass moments!

Tags
devchallenge hf26challenge openweights touchgrass

DEV Community: Ziyad Parkar

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

EchoQuest: Turn the Real World into Your RPG 🗺️🌿 #hf26challenge #devchallenge #openweights #touchgrass

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