DEV Community: Arush Singh

SlothSort: A Fully Local Open-Weight File Tidier That Organizes Your Downloads While You

Arush Singh — Tue, 20 Oct 2026 14:38:48 +0000

What I Built

Sorting cluttered directories—especially messy Downloads folders filled with random PDFs, unnamed screenshots, and stray documents—is a chore everyone puts off indefinitely. SlothSort is a lightweight background automation concept designed around the "Slow and Steady" mindset. It passively listens for newly added files, extracts minimal text or metadata, and lets a local open-weight model figure out the proper category and readable name. The system automatically routes items into organized destination folders like invoices, study material, and receipts, letting users be completely lazy while their storage cleans itself up without any manual effort.

Demo

The project runs as a background service with an interactive dashboard that logs real-time file categorization. Whenever a new file is dropped into an unorganized folder, the interface highlights the detected item, shows the extracted summary, and visually updates the destination path as the file is sorted automatically.
Code

The core implementation consists of an automation script built around a file watcher loop and structured prompting. It intercepts file system creation events, invokes a lightweight local model via standard inference APIs to return clean JSON output containing the target directory and sanitized file name, and safely handles file relocation across local disks.
How I Built It

The architecture uses Ollama and llama.cpp to host compact, quantized open-weight models such as Qwen2.5-1.5B or Llama-3.2-1B directly on local hardware. File system monitoring is handled via Python's watchdog library to keep CPU usage negligible while waiting for new files. For reading incoming data, local open-source utilities like pypdf and pytesseract extract high-signal text snippets, which are then passed into the model using strict formatting to generate predictable, safe directory paths.

Why Does Open Innovation Matter?

Open innovation ensures complete privacy and zero running costs. Personal receipts, tax documents, and private notes never leave the machine or touch third-party cloud servers. Unlike closed proprietary APIs that charge per-token fees for constant background queries, local open weights run indefinitely for free. The setup works seamlessly without an internet connection and offers the freedom to swap, configure, or fine-tune models to fit any system hardware without external vendor locks.

Building a Privacy-First Expense Sorter with Open-Source AI for Freelancers

Arush Singh — Tue, 13 Oct 2026 00:28:42 +0000

What I Built
LedgerShield is a local-first receipt and invoice categoriser built for freelancers, consultants, and micro-business owners who need automated bookkeeping without handing sensitive financial records over to third-party cloud platforms.

Users drag and drop mixed receipts—scanned PDFs, smartphone photos, and digital bills—into a clean interface. LedgerShield extracts key metadata (vendor name, date, total amount, taxes, and category) and exports them into structured CSV or JSON formats.

Interface: Fast drag-and-drop web dashboard.
Inference Core: Open-weight vision model processing receipts entirely on the local device.

Architecture: Python backend with a lightweight SQLite database for local persistence.
Why Open Innovation Matters for This Build
Handling invoices, tax slips, and client agreements introduces strict privacy and cost constraints where proprietary cloud APIs fall short:

Strict Data Privacy: Open-weight models run locally on the user's laptop, ensuring sensitive financial documents, client names, and tax identifiers never leave their hardware or get used to train closed corporate systems.

Predictable Unit Economics: Closed APIs charge per image and token, which erodes margins for low-ticket side hustles. Open-weight inference runs at zero incremental API cost, making it viable as a lightweight subscription or one-time license.

Offline Reliability & Sovereignty: Freelancers frequently travel or work on spotty internet. Because the model runs locally, processing works without an active connection, immune to sudden API rate limits or deprecations.

The Side Hustle Angle: First User Validation
To validate demand, I shared an early build with a freelance designer who routinely wastes hours sorting expenses at the end of every tax cycle:

The Test: They processed 18 mixed receipts—including paper fuel slips and digital software subscriptions.
Results: The extraction parsed line totals and vendor details in under three minutes, eliminating manual spreadsheet entry.
User Feedback: The user stated they would gladly pay a one-time utility fee or modest monthly rate for automated weekly CSV exports. Their primary feature request for the next release was automated multi-currency conversion.
Tech Stack
Model: Open-weight vision-language model running via local inference

Backend: Python, SQLite
Deployment & Hosting: Render (hosting the public landing page and documentation service)

🌿 TrailBreeze: An Offline Open-Weight AI Companion Designed to Get You Outside

Arush Singh — Tue, 06 Oct 2026 11:03:33 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge: Week 1: Touch Grass.
What I Built & How It Gets People Outside
Screen time fatigue is real. Most modern AI apps encourage users to stare at interfaces, prompt-engineer walls of text, and remain indoors.
TrailBreeze is an open-source, edge-first AI concept designed with one core philosophy: make the screen the shortest part of the interaction.
Instead of an endless chatbot feed, TrailBreeze acts as a lightweight, screen-minimized outdoor companion. You tap a single button, describe your current energy level or surroundings, and the assistant suggests a 20-to-30-minute outdoor micro-activity—such as identifying local trees, walking a scenic detour, or observing neighborhood birds. Once your prompt is served, the app voluntarily locks its interface with an encouraging reminder: "Go touch grass, we'll talk when you get back."
Why Open Innovation Matters
TrailBreeze relies on open-weight models (such as Google's Gemma 2B) and local web runtimes for three primary reasons:
True Offline Trail Capability: When exploring parks, forests, or trailheads, cellular data and connectivity frequently drop. A cloud-dependent proprietary API fails instantly in the woods. Open-weight models can be quantized and bundled locally, ensuring the assistant works reliably without an active internet connection.
Zero Surveillance & Total Privacy: Outdoor habits, location patterns, and personal time-away logs belong strictly to the user. Running inference locally guarantees that personal movement data is never harvested by advertising servers.
Low Latency & Energy Efficiency: By running quantized open-source models, response generation takes seconds and consumes minimal battery—crucial when preserving phone life during long outdoor strolls.
How the App Works
User Input: While outdoors, you tap once to ask for a short nature activity.
Offline Processing: The app runs a lightweight, open-source model locally on the device without requiring an active internet connection.
Short Prompt: The app generates a concise, two-sentence outdoor activity suggestion.
Screen Lockout: The interface automatically pauses for 20 minutes to encourage you to put your phone away and explore.
What I Learned
Exploring this week's "Touch Grass" theme highlighted that open-source AI isn't just about raw compute power—it is about deployment freedom. Proprietary models lock experiences behind high-bandwidth APIs and screen-centric applications. Open weights allow developers to craft intentional, offline-first utilities that respect human attention and encourage us to disconnect from digital noise and reconnect with the physical world.

OpenEdge: Building an Offline First-Aid & Emergency Assistant with Open-Source

Arush Singh — Fri, 02 Oct 2026 03:19:31 +0000

What I Built

During natural disasters, connectivity loss, or travel in remote regions, standard cloud-based AI solutions become inaccessible the moment an internet connection drops. In high-stakes emergency situations, triage advice should never depend on network bandwidth, paid API keys, or remote cloud servers.

To solve this, I designed OpenEdge, a lightweight, offline-first emergency triage assistant built with open-source AI at its core. It operates directly inside any modern web browser to deliver deterministic, step-by-step first-aid guidance (such as CPR cadences, severe bleeding protocol, burn classification, and fracture stabilization) completely offline.

Why Open-Source AI Matters Here

Centralized closed models fail in two major areas during emergencies:

Network Availability: When a tower goes down or an area lacks coverage, API-based models are non-functional.
Data Sovereignty & Cost: Edge-deployed open-weight models have zero running cost once downloaded and ensure personal health queries remain private on the user's device.

Using open weights allows the application to embed model runtimes directly on-device using WebAssembly (Transformers.js / ONNX Runtime Web). By relying on small, efficient open-weight models like SmolLM or Gemma 2B, the system provides structured, life-critical triage steps without transmitting a single byte to an external server.

Technical Stack & Architecture

Core Model Engine: Open-weight language model quantized to 4-bit weights for low-memory edge devices.
Client Runtime: WebAssembly (Wasm) and WebGPU via ONNX / Transformers.js to execute inferences client-side.
Triage Architecture: Constrained decoding with temperature controls ($T \le 0.2$) paired with prompt-anchored decision trees to eliminate conversational filler and focus purely on actionable instructions.
Local Cache: PWA service workers and Cache API to allow instant offline reload.

What I Learned

Designing an AI system around open weights shifts the focus from simple prompt engineering to resource optimization:

Small Models Excel at Focused Tasks: A general 70B model is unnecessary for structured emergency triage. A fine-tuned or strictly prompt-bound 1B–2B open model performs reliably while remaining responsive on everyday hardware.
True Portability: Open-source AI ensures developers can deploy software anywhere—from a web browser on a phone to an embedded device in a disaster relief kit—without gatekeepers or licensing bottlenecks.

What's Next

Adding voice-prompt interaction through open-source on-device Whisper models for hands-free guidance.
Integrating offline mesh-network relays to sync emergency status reports across local devices without cellular towers.

OpenEdge: Building an Offline First-Aid & Emergency Assistant with Open-Source AI

Arush Singh — Fri, 02 Oct 2026 03:14:26 +0000

What I Built

Why Open-Source AI Matters Here

Centralized closed models fail in two major areas during emergencies:

Network Availability: When a tower goes down or an area lacks coverage, API-based models are non-functional.
Data Sovereignty & Cost: Edge-deployed open-weight models have zero running cost once downloaded and ensure personal health queries remain private on the user's device.

Technical Stack & Architecture

Core Model Engine: Open-weight language model quantized to 4-bit weights for low-memory edge devices.
Client Runtime: WebAssembly (Wasm) and WebGPU via ONNX / Transformers.js to execute inferences client-side.
Triage Architecture: Constrained decoding with temperature controls ($T \le 0.2$) paired with prompt-anchored decision trees to eliminate conversational filler and focus purely on actionable instructions.
Local Cache: PWA service workers and Cache API to allow instant offline reload.

What I Learned

Designing an AI system around open weights shifts the focus from simple prompt engineering to resource optimization:

Small Models Excel at Focused Tasks: A general 70B model is unnecessary for structured emergency triage. A fine-tuned or strictly prompt-bound 1B–2B open model performs reliably while remaining responsive on everyday hardware.
True Portability: Open-source AI ensures developers can deploy software anywhere—from a web browser on a phone to an embedded device in a disaster relief kit—without gatekeepers or licensing bottlenecks.

What's Next

Adding voice-prompt interaction through open-source on-device Whisper models for hands-free guidance.
Integrating offline mesh-network relays to sync emergency status reports across local devices without cellular towers.

Intro

Arush Singh — Thu, 01 Oct 2026 12:18:10 +0000

I am new to dev community