DEV Community: taha

Vaultledger: a Freelance essential

taha — Wed, 14 Oct 2026 00:29:43 +0000

What I Built

As a computer science student juggling freelance development, keeping track of messy PDF invoices, parsing tax rates, and formatting general ledger journal entries is a major distraction.

I built VaultLedger: a 100% offline, air-gapped desktop utility for freelancers and independent contractors that ingests messy invoices and receipts (PDFs and images), extracts structured financial line items, forces deterministic schema extraction via an embedded local Google Gemma 2B (Q4_K_M GGUF) model, persists records in a WAL SQLite database anchored by a SHA-256 tamper-evident hash chain, and exports audit-ready Double-Entry General Ledger CSVs.

Freelancers and small business owners pay for this with absolute privacy: zero cloud dependencies, zero data leaks, and zero risk of proprietary tax data hitting third-party LLM APIs.
Demo

GitHub Repository: tahaenasraoui-debug/vault-ledger

[]()

Code

You can embed your repository directly using Dev.to's GitHub tag:

tahaenasraoui-debug / vault-ledger

🛡️ VaultLedger

Air-Gapped Local AI Financial Extraction & Cryptographic Double-Entry Ledger

Zero Cloud. Zero Telemetry. 100% On-Device Rust + Quantized Gemma 2B Inference.

⚡ Overview

Freelancers, auditors, and privacy-critical businesses shouldn't have to upload sensitive invoices, tax IDs, and banking records to third-party cloud APIs just to automate bookkeeping.

VaultLedger is a strictly air-gapped, local-first desktop application engineered in Rust and Tauri v2. It ingests messy PDF invoices or receipt photos, extracts structured accounting line items using an embedded Google Gemma 2B (Q4_K_M GGUF) model running via pure-Rust Candle tensors, anchors every record into a SHA-256 tamper-evident SQLite database, and exports balanced Double-Entry General Ledger CSVs.

🔒 The Air-Gap Guarantee

Compile-Time Network Ban: build.rs inspects the resolved Cargo dependency graph at compile time and panics if any HTTP/network crate (reqwest, curl, hyper, ureq) is present.
Memory Safety: Compiled with #![forbid(unsafe_code)] across the…

View on GitHub

Core architectural highlights from the codebase:

The Air-Gap Enforcer (src-tauri/build.rs): A compile-time guardrail that scans resolved Cargo dependencies and panics the build if any network/HTTP client (reqwest, curl, hyper) is introduced.

Local AI Engine (src-tauri/src/inference.rs): Loads quantized Gemma 2B Instruct via pure-Rust candle-core and candle-transformers, streaming token pieces over Tauri v2 events.

Tamper-Evident Vault (src-tauri/src/storage.rs): Implements active and audit hash chains (prev_chain_hash -> chain_hash) in SQLite WAL mode.

How I Built It

VaultLedger is built around open-weight local inference and strict systems-level Rust:

Framework: Tauri v2 (core = "2") with multi-threaded async IPC commands routing CPU-heavy tasks to background Tokio blocking threads.

Local LLM Inference Engine: HuggingFace's pure-Rust candle framework running Google Gemma 2B Instruct quantized to Q4_K_M, paired with local HuggingFace tokenizers.

Hybrid Ingestion Pipeline: Direct PDF text extraction via lopdf, coupled with an automatic fallback for scanned receipts/photos using contrast enhancement and pure-Rust neural OCR (ocrs + rten weights).

Deterministic Accounting Reconciler: Uses schemars to enforce schema validation, fixed-point integer cent representation (i64) to eliminate IEEE-754 floating-point drift, and trial-balance invariants (net + tax == total).

UI: A sleek, glassmorphic Obsidian Fintech dashboard built with Vite, TypeScript, and custom CSS variables.

Why Does Open Innovation Matter?

Open-source AI and open-weight models made VaultLedger possible. A closed API (like OpenAI or Anthropic) would require sending raw invoices, vendor names, exact amounts, and tax IDs to a corporate server over an active HTTPS connection—violating data privacy laws (like GDPR) and failing strict air-gapped security mandates.

Because of open-weight models like Gemma 2B and pure-Rust tensor libraries like Candle, we can bundle state-of-the-art intelligence directly inside a local desktop binary. It proves that powerful AI automation does not require sacrificing data sovereignty or trusting third-party cloud infrastructure.
My Agent Session

Built iteratively using local developer agent workflows, enforcing #![forbid(unsafe_code)] and strict control-flow error handling via thiserror.

My First User

Tested locally on personal freelance invoices and university project expense receipts in Rabat, Morocco, successfully generating balanced double-entry accounting CSV journals ready for tax audit.

Prize Categories

Open-Source AI / Local Inference

Side Hustle / Developer Productivity

VaultLedger: Freelance essential.

taha — Wed, 14 Oct 2026 00:08:01 +0000

Here is your complete, ready-to-publish Dev.to submission post for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle, tailored directly around VaultLedger!
This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle
What I Built

As a computer science student juggling freelance development, keeping track of messy PDF invoices, parsing tax rates, and formatting general ledger journal entries is a major distraction.

Freelancers and small business owners pay for this with absolute privacy: zero cloud dependencies, zero data leaks, and zero risk of proprietary tax data hitting third-party LLM APIs.
Demo

GitHub Repository: tahaenasraoui-debug/vault-ledger

Add a screen recording GIF here showing a PDF being dragged in, real-time JSON tokens streaming in the neural terminal, the KPI cards updating, and the CSV export.

Code

You can embed your repository directly using Dev.to's GitHub tag:

tahaenasraoui-debug / vault-ledger

🛡️ VaultLedger

Air-Gapped Local AI Financial Extraction & Cryptographic Double-Entry Ledger

Zero Cloud. Zero Telemetry. 100% On-Device Rust + Quantized Gemma 2B Inference.

⚡ Overview

Freelancers, auditors, and privacy-critical businesses shouldn't have to upload sensitive invoices, tax IDs, and banking records to third-party cloud APIs just to automate bookkeeping.

🔒 The Air-Gap Guarantee

Compile-Time Network Ban: build.rs inspects the resolved Cargo dependency graph at compile time and panics if any HTTP/network crate (reqwest, curl, hyper, ureq) is present.
Memory Safety: Compiled with #![forbid(unsafe_code)] across the…

View on GitHub

Core architectural highlights from the codebase:

The Air-Gap Enforcer (src-tauri/build.rs): A compile-time guardrail that scans resolved Cargo dependencies and panics the build if any network/HTTP client (reqwest, curl, hyper) is introduced.

Local AI Engine (src-tauri/src/inference.rs): Loads quantized Gemma 2B Instruct via pure-Rust candle-core and candle-transformers, streaming token pieces over Tauri v2 events.

Tamper-Evident Vault (src-tauri/src/storage.rs): Implements active and audit hash chains (prev_chain_hash -> chain_hash) in SQLite WAL mode.

How I Built It

VaultLedger is built around open-weight local inference and strict systems-level Rust:

Framework: Tauri v2 (core = "2") with multi-threaded async IPC commands routing CPU-heavy tasks to background Tokio blocking threads.

Local LLM Inference Engine: HuggingFace's pure-Rust candle framework running Google Gemma 2B Instruct quantized to Q4_K_M, paired with local HuggingFace tokenizers.

Hybrid Ingestion Pipeline: Direct PDF text extraction via lopdf, coupled with an automatic fallback for scanned receipts/photos using contrast enhancement and pure-Rust neural OCR (ocrs + rten weights).

Deterministic Accounting Reconciler: Uses schemars to enforce schema validation, fixed-point integer cent representation (i64) to eliminate IEEE-754 floating-point drift, and trial-balance invariants (net + tax == total).

UI: A sleek, glassmorphic Obsidian Fintech dashboard built with Vite, TypeScript, and custom CSS variables.

Why Does Open Innovation Matter?

Built iteratively using local developer agent workflows, enforcing #![forbid(unsafe_code)] and strict control-flow error handling via thiserror.

My First User

Tested locally on personal freelance invoices and university project expense receipts in Rabat, Morocco, successfully generating balanced double-entry accounting CSV journals ready for tax audit.

Prize Categories

Open-Source AI / Local Inference

Side Hustle / Developer Productivityapplies, or remove this section. -->

The Verdant Knight: An Offline-First Naturalist RPG Powered by WebGPU

taha — Fri, 09 Oct 2026 23:12:29 +0000

Here is the complete DEV.to post with your YouTube video embedded directly into the Demo section using DEV’s native liquid tag:

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

The Verdant Knight: Chronicles of the Realm is a client-side naturalist RPG designed around zero screen time on outdoor trails.

Most outdoor and fitness applications demand continuous screen engagement—monitoring route metrics, managing social shares, or framing camera angles. The Verdant Knight flips this completely: physical outdoor exploration acts as your crafting bench and leveling system, while your screen stays in your pocket.

Designed for Zero Screen Time: While walking trails, woodlands, or local parks, players keep their phones away. When coming across an interesting natural element, they snap a quick photo using a dedicated shutter button.

Haptic Confirmation: The app triggers tactile vibration pulses (navigator.vibrate([100, 50, 100])) so players can confirm their capture purely by touch without glancing at their screen.

Naturalist Progression Matrix: Specimens map directly to five character RPG stats and gear slots:

    Bark & Timber → Defense (DEF), unlocking cuirasses and plated armors.

    Foliage & Needles → Agility (DEX), unlocking cloaks and wind-runner mantles.

    Stones & Minerals → Strength (STR), unlocking blades and bludgeons.

    Flowers & Berries → Wisdom (WIS), unlocking talismans, amulets, and circlets.

    Fungi, Moss & Lichen → Endurance (END), unlocking spore shields and sashes.

Dynamic Paper-Doll Pixel Avatars: Gear dynamically equips and renders onto a customized pixel-art canvas.

The Field Codex: Every encounter cataloged logs rarity tiers, scientific classifications, and discoveries directly in offline storage.

Demo

Live Web App: Play The Verdant Knight

Video Walkthrough: Watch Trail Demo on YouTube

Android APK Package: Direct Download on GitHub Releases

Code

tahaenasraoui-debug / The-Verdant-Knight-Chronicles-of-the-Realm

An offline-first naturalist RPG powered by on-device open-weight AI (WebGPU). Step outside, photograph the wild, and let nature level up your character sheet—with zero screen time on the trail.

🌿 The Verdant Knight: Chronicles of the Realm

An offline-first naturalist RPG powered by on-device open-weight AI (WebGPU).
Built for the Hacktoberfest Open-Source AI Challenge — Week 1: "Touch Grass".

🎬 Demo

Live Web App: Play The Verdant Knight

🌲 Overview

Most outdoor applications encourage users to keep their eyes locked on screens—checking GPS waypoints, tweaking camera filters, or browsing social media feeds.

The Verdant Knight flips this dynamic entirely. It is a client-side naturalist RPG where physical exploration acts as your crafting bench and leveling system.

Players explore outdoor trails, woodlands, or local parks with minimal screen interaction. When spotting interesting natural elements, they snap a single photograph. An open-weight vision model processes the image locally on their device, evaluates the specimen, attunes the find to one of five core elemental attributes, and logs the discovery inside a field codex.

📱 Android Installation

Download and install the APK…

View on GitHub

How I Built It

The game runs entirely inside the client with zero server dependencies or API keys:

AI Runtime & Local Inference: Powered by Transformers.js v3 (@huggingface/transformers) executing client-side with WebGPU hardware acceleration (with an automatic fallback to WebAssembly SIMD for non-WebGPU environments).

Vision Model Backbone: Uses an open-weight quantized MobileNetV4 neural network (onnx-community/mobilenetv4_conv_small.e2400_r224_in1k). On the very first launch, the browser caches the ~15 MB quantized model into indexed browser cache; from that moment on, all vision classification runs offline.

Pixel-Art Engine: Native HTML5 Canvas handling layered paper-doll asset assembly, procedural palette shifts, and equipment overlay.

Audio Synthesizer: Real-time 8-bit chiptune audio synthesized at runtime using the Web Audio API (no bulky audio files to stream).

Persistence: Entire state, discovered codex entries, player stats, and inventory sync to the browser's localStorage.

Why Does Open Innovation Matters?

Backcountry Offline Execution: The best nature trails, forests, and mountain paths have little to no cellular reception. Cloud-hosted APIs fail the second you lose cell coverage. Open-weight ONNX models paired with in-browser WebGPU run anywhere on Earth without an internet connection.

True Location & Visual Privacy: Trail photographs embed EXIF geolocation tags and personal environmental snapshots. By utilizing open-weight inference locally on the device, no visual feed, metadata, or coordinates ever leave the user's phone.

Zero Marginal Inference Cost: Open innovation allows indie developers to distribute functional AI applications without paying subscription fees or bearing usage token overheads.

Prize Categories

Main Track: Hacktoberfest Open-Source AI Challenge Week 1: "Touch Grass"

Team Submissions

Lead & Development: @tahaenasraoui-debug

MakeFud — Zero-Build Recipe Discovery from Whatever is in Your Fridge

taha — Sun, 04 Oct 2026 21:13:18 +0000

What I Built

MakeFud is an ultra-lean, zero-build web app built to transform scattered kitchen ingredients into wholesome, affordable home-cooked meals.
The Story: Cooking for Walid

I built MakeFud for my close friend Walid. Living on his own comes with a demanding routine, tight finances, and the daily grind of running a solo household. Time and again, the same routine played out: Walid would return home exhausted, open his fridge, stare blankly at a stray tomato, a couple of eggs, an onion, and some dry lentils, sigh, and shut the door.

When money is tight and energy is depleted, decision fatigue takes over. A few basic staples don't immediately feel like a complete dinner, making it tempting to skip the meal altogether or spend hard-earned cash on fast food.

Walid didn't need complicated cooking apps filled with 25-step gourmet recipes or exotic seasonings he couldn't afford. He needed a practical, reliable tool to turn what he already had into a nutritious, filling plate without the stress.
How MakeFud Solves It

MakeFud strips away the cognitive friction of cooking on a budget:

Ingredient-First Discovery: Walid simply types the items sitting on his shelf or counter (like egg, rice, or tomato). MakeFud instantly surfaces recipes prioritizing dishes that use those exact items with the fewest missing ingredients.

Transparent Missing Ingredients: Instead of surprising the user midway through prep, each recipe card clearly highlights what is already on hand versus the exact extra items required.

Zero-Cost Instant Sorting: Walid can sort recommendations client-side by preparation time (for quick dinners between tasks), calorie count (to ensure he gets sustained energy), or total ingredient count (to minimize cleanup and dishes).

Offline Mock Data: When mobile data is spotty or an API key isn't configured, a built-in demo mode provides offline pantry-friendly ideas without needing external accounts or credentials.

Demo

Live Deployment: https://tahaenasraoui-debug.github.io/makefud-app/

Local Run: Clone the repo and run python3 -m http.server, then open http://localhost:8000.

No-Key Demo Mode: The app includes a built-in mock dataset so anyone can test recipes immediately without signing up for third-party services.

Code

tahaenasraoui-debug / makefud-app

Zero-build web app that finds healthy recipes from whatever ingredients you have in your fridge. Built with vanilla HTML/JS and the Spoonacular API.

MakeFud 🍳

Empty fridge? Type what you have. Get recipes sorted by prep time, calories, or ingredient count.

MakeFud is a zero-build, ultra-lean web application that turns whatever ingredients you have left in your pantry or fridge into healthy, realistic meals[cite: 1, 3]. It minimizes food waste and takes the stress out of cooking on a budget or with limited time.

Preview

Features

Fridge-to-Plate Matching: Enter whatever raw ingredients you have on hand to find recipes that maximize what you already own[cite: 3].
Missing Ingredients Breakdown: In-browser fuzzy matching shows exactly which extra items a recipe needs[cite: 3].
Zero-Cost Sorting: Instant client-side sorting by preparation time, calories per serving, or total ingredient count[cite: 3].
Offline / Demo Mode: Ships with built-in mock recipes so you can run and test the app immediately without an API key or internet connection.
Zero-Build Architecture: Pure HTML, native CSS, and vanilla ES6+. No npm…

View on GitHub

The project is built with zero runtime dependencies and contains four primary files:

index.html – The complete, responsive single-page application built with semantic HTML, fluid native CSS with light/dark theme detection, and vanilla ES6+.

CONTRIBUTING.md – Clear ground rules, accessibility standards, and beginner-friendly issues for Hacktoberfest contributors.

DISCLAIMER.md – Nutrition and medical disclaimers, plus third-party API attribution guidelines.

LICENSE – MIT License.

How I Built It

To ensure Walid could pull this up on a cheap phone or slow connection instantly, I imposed strict design constraints:

Zero-Build & Zero-Dependency Stack: No bundlers, npm packages, or heavy UI frameworks. Everything runs directly in the browser via standard Web APIs.

Local Ingredient Fuzzy-Matching: Missing ingredients are calculated client-side by fuzzy-matching input tags against recipe components, saving quota and running with zero latency.

Dual Data Modes: Operates both with live queries to the Spoonacular API (delivering exact calorie counts and prep times) and a self-contained offline dataset of quick, budget-friendly pantry dishes.

Privacy & Security by Design: API keys live entirely in the user's localStorage and are sent exclusively to the upstream provider. All API-derived strings are sanitized before injection to prevent XSS.

Why Does Open Innovation Matter?

When software is built behind walled gardens or proprietary platforms, basic everyday tools get bloated with trackers, invasive subscription tiers, and paywalled features.

Open innovation makes essential utilities accessible to everyone. Because MakeFud is open-source and zero-build, someone in Walid’s exact shoes doesn't have to surrender their privacy or watch ads just to figure out how to cook an egg and a potato. Furthermore, anyone during Hacktoberfest can fork the repository, add staple toggles, improve ingredient pluralization, or introduce localized pantry ingredients without ever having to configure a compiler.
Prize Categories

Hacktoberfest Weekend Challenge: Build for a Friend

Team: Solo / None (Built independently by Mohamed Taha Enasraoui)