DEV Community: Khoa.Vo

Engineering KV Files PRO: 3D CAD Viewports, Adobe PSD Parsers & Offline Ed25519 Licensing in Rust

Khoa.Vo — Wed, 23 Sep 2026 12:34:57 +0000

Engineering KV Files PRO: 3D CAD Viewports, Adobe PSD Parsers & Offline Ed25519 Licensing in Rust

Following the release of the open-source KV Files web file manager, teams working in architecture, industrial engineering, and creative agencies reached out with advanced enterprise needs:

Viewing massive 3D CAD and BIM engineering models (DWG, DXF, IFC, STEP, STL) directly inside the browser without installing expensive CAD desktop software.
Inspecting multi-layer Adobe Photoshop (PSD) and Illustrator (AI) design files without launching Adobe Creative Cloud.
Ensuring compliance in high-security air-gapped enterprise networks through 100% offline asymmetric cryptographic licensing.

To address these requirements, I engineered KV Files PRO (kv-file-pro).

⚡ Key Commercial Capabilities

1. Universal 3D CAD & BIM Viewport

Engineers and architects can preview complex 3D assemblies and construction drawings directly inside their browser tab:

Formats Supported: DWG, DXF, IFC (BIM), STEP, IGES, STL, and OBJ.
Hardware-Accelerated WebGL/WebGPU Rendering: Smooth orbital rotation, exploded views, section cuts, and measurement calipers.
Zero Software Footprint: Team members on tablets or budget laptops can inspect millimeter-accurate blueprints without needing specialized desktop workstations.

2. Adobe Creative Suite Layer Parser

Creative studios can preview raw design assets before delivery:

Parses multi-layer Adobe Photoshop (.psd) files on the fly.
Allows toggling individual layer visibility, inspecting layer blending modes, and exporting individual raster assets directly from the file browser.
Previews Illustrator (.ai) and InDesign (.indd) spreads with embedded color profile fidelity.

3. Typography & Font Inspector Studio

Designers can drag and drop OTF, TTF, and WOFF2 font files into a specialized inspector to test custom glyphs, kerning tables, variable font weight sliders, and ligature ligatures in real time.

4. 100% Offline Ed25519 Cryptographic Licensing

Enterprise environments often mandate strict air-gapped isolation from the public internet. KV Files PRO utilizes asymmetric Ed25519 cryptographic signatures:

License keys are validated mathematically against embedded public keys directly inside the Rust binary.
Requires zero internet connectivity, zero outbound telemetry, and zero third-party licensing servers.

📦 Deployment

KV Files PRO is packaged as an optimized commercial Docker container:

docker run -d \
  --name kv-file-pro \
  -p 8080:8080 \
  -v /enterprise/storage:/data \
  -v ./kv-pro-data:/config \
  -e LICENSE_KEY="your-ed25519-license-key" \
  vndangkhoa/kv-file-pro:latest

🔗 Learn More

Explore full documentation, interactive live demos, and licensing details:

🌐 KV Files PRO Portal: https://vndangkhoa.github.io/kv-file/#pro

⭐ GitHub Organization: https://github.com/vndangkhoa

Building a Mobile-First Social Media Video Downloader with Go and yt-dlp

Khoa.Vo — Wed, 23 Sep 2026 12:34:24 +0000

Building a Mobile-First Social Media Video Downloader with Go and yt-dlp

Downloading videos from platforms like TikTok, YouTube, Instagram Reels, and Twitter/X on a mobile device is notoriously painful. Most public downloader websites are loaded with deceptive popups, malware redirect ads, and arbitrary file size limits.

I wanted a clean, self-hosted web tool that I could pin to my phone's home screen as a Progressive Web App (PWA) to grab videos cleanly in one tap.

That led to KV-Download: a mobile-friendly media downloader powered by Go 1.24+ and yt-dlp.

🎬 Key Features

📱 Mobile-First UX: Designed from the ground up for phone viewports with clean touch targets, swipe actions, and one-tap clipboard pasting.
⚡ High-Concurrency Go Engine: Uses Go routines to handle parallel downloads, format resolution, and stream chunking with minimal memory overhead.
🌐 Multi-Platform Support: Downloads from hundreds of video platforms supported by yt-dlp (TikTok, YouTube Shorts, Reddit, Instagram, X/Twitter, Vimeo).
🚫 100% Ad-Free & Private: Zero tracking scripts, zero popups, and no cookies stored on third-party servers.
📦 Single Docker Container: Ships with all required dependencies (go binary, ffmpeg, and yt-dlp) pre-installed.

🚀 Quick Start with Docker

docker run -d \
  --name kv-download \
  -p 8080:8080 \
  vndangkhoa/kv-download:latest

Open http://<your-server-ip>:8080 on your phone, tap "Add to Home Screen", and enjoy seamless video downloads on the go!

🔗 Check it Out on GitHub

KV-Download is open-source under the MIT license:

⭐ GitHub Repository: https://github.com/vndangkhoa/kv-download

🐳 Docker Hub: vndangkhoa/kv-download

Managing Synology NAS with AI: Building KV-Synology with a 42-Tool MCP Server

Khoa.Vo — Wed, 23 Sep 2026 12:33:51 +0000

Managing Synology NAS with AI: Building KV-Synology with a 42-Tool MCP Server

Synology DiskStation Manager (DSM) is arguably the gold standard of NAS operating systems. However, its native web desktop interface can feel heavy and latency-prone, especially over remote networks or on lower-power NAS hardware.

Furthermore, with the rise of AI agents like Claude, Gemini, and ChatGPT, managing complex NAS operations (storage pool health, container states, firewall rules, and automated backups) should be conversational and automated.

To bridge this gap, I created KV-Synology: a modern, zero-telemetry management dashboard built with Next.js 15 & React 19, combined with a native Model Context Protocol (MCP) AI Server.

🎛️ What is KV-Synology?

KV-Synology acts as an ultra-fast management layer over your Synology DSM:

Instant Response Times: Built on Next.js 15.5, React 19, and Tailwind CSS v4, loading dashboard telemetry and volume metrics in milliseconds.
Zero Telemetry & Tracking: No third-party analytics or phone-home requests; everything connects directly to your local DSM API endpoints.
Container & Task Insights: Real-time visibility into Docker / Container Manager stacks, CPU/RAM utilization, and temperature sensor readouts.

🤖 The AI Model Context Protocol (MCP) Server

The most revolutionary part of KV-Synology is its native Model Context Protocol (MCP) server equipped with 42 dedicated management tools.

By connecting KV-Synology to an AI client (Claude Desktop, Antigravity, Cursor, or Open-WebUI), your AI agent can safely execute structured tasks:

User: "Check the health of my storage pools, report any failing SMART disks, and list any Docker containers using more than 2GB of RAM."

AI Agent:
  ➔ Calls `dsm_storage_pool_status`
  ➔ Calls `dsm_smart_disk_health`
  ➔ Calls `docker_container_stats`
  ➔ Synthesizes immediate actionable diagnostics!

Available MCP tool categories include:

System & Hardware Telemetry: CPU load, RAM allocation, thermal sensors, fan speeds, and uptime.
Storage Management: Volumes, storage pools, RAID scrub schedules, and SMART diagnostic logs.
Container Manager: Inspect, start, stop, restart, and retrieve logs for Docker containers.
File Operations & Shares: Enumerate shared folders, permissions, and disk quotas.
Security & Firewalls: Inspect active connection sockets, IP auto-block lists, and certificate expiry.

🚀 Quick Start with Docker

You can run KV-Synology on your Synology NAS using Container Manager or Docker CLI:

docker run -d \
  --name kv-synology \
  -p 3000:3000 \
  -e SYNO_HOST=192.168.1.100 \
  -e SYNO_PORT=5000 \
  vndangkhoa/kv-synology:latest

🔗 Check it Out on GitHub

KV-Synology is open-source under the GPL-3.0 license:

⭐ GitHub Repository: https://github.com/vndangkhoa/kv-synology

🐳 Docker Hub: vndangkhoa/kv-synology

Building Ola: Anti-Leak DRM Video Review & Media Explorer for Synology NAS

Khoa.Vo — Wed, 23 Sep 2026 12:33:18 +0000

Building Ola: Anti-Leak DRM Video Review & Media Explorer for Synology NAS

Creative video production houses, visual effects studios, and post-production agencies frequently face a dangerous problem: unreleased video leaks.

When sharing early cuts, client approvals, or commercial drafts with external stakeholders:

Sharing raw files via Google Drive or Dropbox leaves video files completely unprotected against screen recording, ripping, or unauthorized redistribution.
Commercial review SaaS platforms (like Frame.io) charge steep per-seat monthly subscription fees and require moving gigabytes of sensitive raw footage out of your local studio NAS into foreign cloud storage.

To give creative studios enterprise-grade video review security hosted entirely on their own infrastructure, I built Ola.

🛡️ What is Ola?

Ola is a self-hosted media explorer and client review platform engineered specifically for Synology NAS (DSM 7.x & 6.x) and Docker environments:

1. Forensic Anti-Leak DRM Video Player

When a client or external collaborator views an unreleased video:

Dynamic Floating Watermarks: Renders the client's email, IP address, and dynamic timestamp moving smoothly across the video frames, discouraging camera recording and screen captures.
Encrypted Media Chunks: Media streams are segmented and encrypted on the fly via Go memory buffers, preventing straightforward browser devtools media downloads.
Expiry & Password Controls: Granular access tokens with time-decay links and view limits.

2. Dual-Pane Studio File Manager

Creative directors and editors can navigate studio storage pools using an ergonomic dual-pane split view, comparing project folders and moving render assets seamlessly.

3. Zero-Config P2P Tunnels

Ola includes automated secure tunneling, allowing clients outside your local office network to access review portals without complex router port-forwarding or public IP exposure.

4. Native Synology SPK & Docker

Ships as a native .spk package installable directly through Synology DSM Package Center, as well as a Docker container for general Linux servers.

🚀 Quick Start with Docker

docker run -d \
  --name ola-user \
  -p 8080:8080 \
  -v /volume1/projects:/data \
  vndangkhoa/ola-user:latest

Open http://localhost:8080 to initialize the studio workspace.

🔗 Check it Out on GitHub

Ola is open-source under the MIT license:

⭐ GitHub Repository: https://github.com/vndangkhoa/ola

🐳 Docker Hub: vndangkhoa/ola-user

KV-Music: Self-Hosted YouTube Music Streamer with Rust Axum, React 19 & Synced Lyrics

Khoa.Vo — Wed, 23 Sep 2026 12:32:45 +0000

KV-Music: Self-Hosted YouTube Music Streamer with Rust Axum, React 19 & Synced Lyrics

Commercial music streaming services lock your playlists into walled gardens, collect invasive listening habit metrics, and continuously hike subscription prices.

While Spotify and Apple Music dominate the mainstream, YouTube Music actually hosts the largest catalog of obscure remixes, live concerts, anime OSTs, and independent indie releases on the internet.

To create the ultimate private music portal, I built KV-Music: a high-performance web player and sync hub powered by a Rust Axum backend and a React 19 frontend.

🎧 What Makes KV-Music Special?

1. The Entire YouTube Music Catalog, Self-Hosted

Stream millions of songs, albums, and user playlists directly without ads or intrusive sponsored breaks.

2. Time-Synced Dynamic Lyrics

Enjoy real-time karaoke-style lyric scrolling synced down to the millisecond. It queries open lyric databases (LRCLIB) and embeds dynamic syllable highlights.

3. Multi-Device Pairing & Sync

Pair your mobile phone, laptop, and living room TV with a simple 6-digit sync code or QR code. Playlists, favorite tracks, and listening queue states stay updated everywhere in real-time over WebSockets.

4. High-Performance Rust (Axum) Backend

Audio caching, metadata parsing, and stream chunking are driven by Rust 1.88+ and Axum, achieving sub-10ms response times while using under 20 MB of RAM.

5. Native Android App (Kotlin)

In addition to the progressive web app (PWA), KV-Music includes a native Android companion app written in Kotlin, featuring system media notification integration, lockscreen scrubber, and Android Auto support.

🚀 Quick Start with Docker

Run KV-Music with Docker in seconds:

docker run -d \
  --name kv-music \
  -p 8080:8080 \
  -v ./kv-music-data:/data \
  vndangkhoa/kv-music:latest

Open http://localhost:8080 to start streaming your favorite tracks!

🔗 Check it Out on GitHub

KV-Music is open-source under the MIT license:

⭐ GitHub Repository: https://github.com/vndangkhoa/kv-music

🐳 Docker Hub: vndangkhoa/kv-music

KV-Tidal: Bit-Perfect Audiophile Streaming & OpenSubsonic Server for Synology NAS

Khoa.Vo — Wed, 23 Sep 2026 12:32:12 +0000

KV-Tidal: Bit-Perfect Audiophile Streaming & OpenSubsonic Server for Synology NAS

For music lovers and homelab audiophiles, streaming high-resolution lossless music (24-bit/192kHz FLAC, ALAC, and DSD) usually requires juggling fragmented tools:

Running heavy desktop clients like Roon (costing hundreds of dollars).
Setting up complex Subsonic servers that transcode or downsample audio streams.
Manually hunting for rare, out-of-print lossless releases on desktop P2P clients.

I wanted a single, unified homelab solution designed specifically for Synology NAS and high-fidelity sound systems.

That is why I created KV-Tidal: an audiophile vault and streaming platform supporting native Synology SPK packages, Docker, Soulseek P2P, and the OpenSubsonic ecosystem.

🎵 What Makes KV-Tidal Unique?

1. Bit-Perfect Studio Master Streaming

KV-Tidal never compromises audio fidelity. It streams direct, uncompressed master audio:

Up to 24-bit / 192kHz FLAC & WAV bit-perfect streaming.
DSD / DSF Direct Stream Digital playback.
Lossless gapless playback engine built with Rust (Axum + Tokio) for zero-latency buffering.

2. Built-in OpenSubsonic Server Protocol

KV-Tidal speaks the standardized OpenSubsonic v1.16.1 API. That means you can connect any existing desktop or mobile Subsonic app:

iOS: Symfonium, iSub, substreamer, play:Sub.
Android: Symfonium, DSub, Tempo.
Desktop: Feishin, Supersonic, Clementine.

You get your private, self-hosted music library in your pocket everywhere you go.

3. Native Bundled Soulseek P2P Lossless Engine

One of KV-Tidal's most distinctive features is an embedded Soulseek P2P client:

Search for rare vinyl rips, Japanese CD editions, and uncompressed studio masters directly inside the web UI.
Download directly into your NAS music folder with automatic ID3 tagging and cover art embedding.
No need to run separate desktop clients or wine wrappers on your server.

4. Native Synology SPK + Docker Support

KV-Tidal ships as both a native Synology DSM 7.x Package (.spk) and a multi-architecture Docker container:

Installs in DSM Package Center with 1 click.
Binds directly to Synology hardware audio interfaces and USB DACs.

🚀 Quick Start with Docker

docker run -d \
  --name kv-tidal \
  -p 3000:3000 \
  -v /volume1/music:/music \
  -v ./kv-tidal-config:/config \
  vndangkhoa/kv-tidal:latest

Open http://<your-nas-ip>:3000 to access the audiophile portal.

🔗 Check it Out on GitHub

KV-Tidal is open-source under the MIT license:

⭐ GitHub Repository: https://github.com/vndangkhoa/kv-tidal

🐳 Docker Hub: vndangkhoa/kv-tidal

KV-Tube: How I Built a Self-Hosted YouTube Alternative in a Single Docker Container

Khoa.Vo — Wed, 23 Sep 2026 12:29:18 +0000

KV-Tube: How I Built a Self-Hosted YouTube Alternative in a Single Docker Container

Modern video streaming platforms have become increasingly cluttered with unskippable multi-minute ads, invasive user tracking, sponsored segments, and algorithmic rabbit holes designed to maximize watch-time rather than user value.

Alternative frontends like Invidious or Piped exist, but managing their multi-service container stacks, external PostgreSQL instances, and fragile public API proxies can be difficult to maintain on a personal server.

I wanted a clean, self-contained solution: a single Docker container that provides a lightning-fast, private YouTube streaming experience with built-in sponsor skipping, playlist sync, and a responsive interface that works just as well on Android TV as it does on a desktop browser.

That project is KV-Tube.

🎬 What is KV-Tube?

KV-Tube is a self-hosted web portal that lets you watch YouTube content in up to 4K resolution with complete privacy:

🚫 Zero Ads & Trackers: Direct video streams without ad interruptions or behavioral profiling.
⚡ SponsorBlock Built-in: Automatically skips in-video sponsorship segments, intros, self-promotions, and end credits.
📺 Android TV & Smart Remote Friendly: Keyboard, remote D-pad, and touch-optimized navigation.
🔄 Cross-Device Watch History: Sync watch progress and custom playlists across your phone, tablet, and PC without needing a Google account.
🎵 Background Audio Playback: Listen to podcasts, talks, and music in the background with full lockscreen media controls.

🏗️ Architecture: Go Backend + Next.js Frontend in One Container

A common complaint with self-hosted web apps is multi-container overhead. For KV-Tube, the entire system is bundled into one cohesive Docker image:

┌────────────────────────────────────────────────────────┐
│                   KV-Tube Container                    │
│                                                        │
│   ┌─────────────────────┐      ┌───────────────────┐   │
│   │ Next.js Frontend    │      │ Go Stream Server  │   │
│   │ Modern Responsive UI│◄────►│ Async API Engine  │   │
│   │ (PWA + TV Layout)   │      │ (SponsorBlock/DB) │   │
│   └─────────────────────┘      └─────────┬─────────┘   │
│                                          │             │
│                                ┌─────────▼─────────┐   │
│                                │ Embedded SQLite   │   │
│                                │ History & Config  │   │
│                                └───────────────────┘   │
└────────────────────────────────────────────────────────┘

Go API Service: The backend is written in Go, offering high-concurrency throughput, minimal memory usage, and near-instant cold starts. It handles metadata extraction, video stream URL resolution, and proxy caching.
Next.js Interface: Built with Next.js, Tailwind CSS, and Lucide icons, offering smooth client-side routing, instant search suggestions, and a theater viewing mode.
Embedded SQLite: All user data (watch progress, liked videos, history, and custom subscriptions) is stored in a lightweight local SQLite database—no external PostgreSQL or Redis dependencies required.

⚡ SponsorBlock Integration

KV-Tube integrates directly with the crowd-sourced SponsorBlock API.

When a video plays, KV-Tube queries known sponsor timestamps:

The video player tracks playback time and automatically leaps over sponsor segments without audible audio blips.
The playback scrubber visually marks sponsor segments in distinct colors (sponsor, intro, outro, self-promotion).
Users can toggle which segment types they wish to skip or show in settings.

🚀 Quick Start with Docker

You can spin up KV-Tube in seconds with Docker:

docker run -d \
  --name kv-tube \
  -p 8080:8080 \
  -v ./kv-tube-data:/app/data \
  vndangkhoa/kv-tube:latest

Or with docker-compose.yml:

version: '3.8'

services:
  kv-tube:
    image: vndangkhoa/kv-tube:latest
    container_name: kv-tube
    restart: unless-stopped
    ports:
      - "8080:8080"
    volumes:
      - ./kv-tube-data:/app/data

Access your private streaming portal at http://localhost:8080!

🔗 Check it Out on GitHub

KV-Tube is 100% open-source under the MIT license:

⭐ GitHub Repository: https://github.com/vndangkhoa/kv-tube

🐳 Docker Hub: vndangkhoa/kv-tube

Feel free to open issues, contribute, or drop a star if you find it helpful!

Designing a Procedural Tetris-Tiled Homelab Dashboard with a Zero-Dependency Backend

Khoa.Vo — Wed, 23 Sep 2026 12:28:45 +0000

Designing a Procedural Tetris-Tiled Homelab Dashboard with a Zero-Dependency Backend

If you browse r/homelab or self-hosted communities, you'll see dozens of dashboards: Homepage, Dashy, Flame, Homer, and others.

While they are capable tools, they often suffer from two common design patterns:

Visual Monotony: Almost every dashboard is either a flat 12-column CSS grid or a list of bootstrap cards. After a while, they all look the same.
Dependency Bloat: Running a dashboard often requires dozens of npm dependencies or external authentication proxies (like Authelia or Authentik) just to protect access.

I wanted a personal launchpad that was playful, visually striking, yet rock-solid and secure.

That inspired KV Home: a procedural Tetris-tiling personal dashboard and homelab hub.

🕹️ The Procedural Tetris Layout Engine

Instead of placing cards into rigid rectangular slots, KV Home uses an in-browser backtracking constraint solver to pack your service links into interlocking tetromino shapes (I, J, L, O, S, T, Z):

┌────────────────────────────────────────────────────────────────────────────────────────┐
│ [🕹️ KV Home]                             [🎲 Re-roll] [🌙 Dark] [⚙️ Admin (Ctrl+Shift+A)] │
├────────────────────────────────────────────────────────────────────────────────────────┤
│   ┌──────────────┐┌──────────────┐┌────────────────────────────┐┌──────────────┐      │
│   │ 📁 KV Files  ││ 🔮 SysVis.AI ││ 📥 KV-DL Downloader        ││ 🌐 Blog      │      │
│   │ Rust Manager ││ System AI    ││ Zero-Disk YouTube Engine   ││ Tech Notes   │      │
│   └──────┬───────┘└──────┬───────┘└─────────────┬──────────────┘└──────┬───────┘      │
│          │ ┌─────────────┴┐ ┌───────────────────┴──┐ ┌─────────────────┴────┐          │
│          │ │ 📺 Jellyfin  │ │ 🐳 Portainer Stack   │ │ 📊 Grafana Metrics   │          │
│          │ │ 4K Media     │ │ Docker Services      │ │ Cluster Monitor      │          │
│          └─┴──────────────┘ └──────────────────────┘ └──────────────────────┘          │
└────────────────────────────────────────────────────────────────────────────────────────┘

How the Layout Solver Works:

Aspect Ratio Analysis: The engine evaluates the client's screen width and determines the optimal grid matrix size.
Tetromino Fitting: A recursive backtracking algorithm tiles the matrix with zero empty holes, assigning random tetromino geometries to each of your services.
SVG clipPath Rendering: Using dynamic SVG clipping and CSS calc(), individual blocks form continuous geometric shapes with consistent gutters and zero visual seams.
Interactive Re-Roll: Click the 🎲 Re-roll button or press space, and the engine re-seeds the solver, animating new falling tetrominoes into position!

🔒 Hardened Zero-Dependency Node.js Backend

One of my core design goals was eliminating runtime third-party dependency vulnerabilities.

The KV Home backend uses only standard Node.js built-in modules:

node:http: Fast native HTTP/1.1 request handling.
node:crypto: High-speed cryptographic operations.
node:fs / node:path: Local configuration persistence and asset serving.

Zero third-party npm packages are loaded in production. This dramatically minimizes security attack surfaces and memory overhead.

Built-in RFC 6238 TOTP 2FA

Securing your homelab dashboard usually involves configuring a complex reverse proxy with OAuth/OIDC.

KV Home includes a native implementation of RFC 6238 Time-Based One-Time Passwords (TOTP) written with node:crypto. You can scan a QR code with Google Authenticator, 1Password, or Bitwarden directly from the setup wizard, providing robust 2-factor protection out of the box with zero external dependencies.

🛠️ Live In-Place Admin Mode (`Ctrl + Shift + A`)

No need to open terminal sessions, edit YAML files, and reload Docker containers every time you add a new service.

Pressing Ctrl + Shift + A activates In-Place Admin Mode:

Add new service cards and category tags directly on the dashboard.
Pick icons, custom accents, and health-check endpoints.
Rearrange priorities with real-time multi-device sync.

🚀 Quick Start with Docker

Deploy KV Home in seconds:

docker run -d \
  --name kv-home \
  -p 3000:3000 \
  -v ./kv-home-data:/app/data \
  vndangkhoa/kv-home:latest

Open http://localhost:3000 to experience your new homelab hub.

🔗 Check it Out on GitHub

KV Home is completely open-source under the MIT license:

⭐ GitHub Repository: https://github.com/vndangkhoa/kv-home

🐳 Docker Hub: vndangkhoa/kv-home

Give your homelab a fresh, tactile look!

SysVis.AI: Running Architecture Diagramming AI 100% Locally in the Browser with WebGPU

Khoa.Vo — Wed, 23 Sep 2026 12:28:12 +0000

SysVis.AI: Running Architecture Diagramming AI 100% Locally in the Browser with WebGPU

Creating clear, accurate system architecture diagrams is one of the most important—and tedious—parts of software engineering.

Typically, engineers find themselves choosing between:

Manual Canvas Editors (Draw.io, Lucidchart): Endless nudging of boxes, misaligned connector arrows, and zero semantic awareness of system design.
Text-to-Diagram Tools (Mermaid, PlantUML): Great for code versioning, but rigid to lay out visually and painful to iterate on with non-technical stakeholders.
Cloud AI SaaS Platforms (Eraser.io): Beautiful, but requires uploading sensitive infrastructure topologies, internal microservice names, and proprietary IPs to third-party cloud servers.

To combine the fluidity of AI diagram generation with complete privacy, I built SysVis.AI (kv-graph): an open-source, local-first system architecture visualizer that runs 100% privately in your browser using WebGPU.

🔮 The Core Concept: Local-First In-Browser AI

SysVis.AI leverages the browser's WebGPU standard to execute modern compact neural networks directly on your client GPU:

Text-to-Diagram: Runs a fine-tuned Qwen3 language model compiled via WebLLM to translate natural language prompts ("Design a real-time event streaming pipeline with Kafka, ClickHouse, and Grafana") into structured diagram graphs.
Vision-to-Diagram: Runs an in-browser vision transformer (ViT-GPT2) to analyze uploaded whiteboard sketches, hand-drawn paper designs, or AWS architecture screenshots and convert them into live editable nodes.
Zero Cloud Leakage: All inference happens directly inside your browser tab. No prompts, architecture data, or uploaded sketches ever leave your machine.

(Note: For users without WebGPU-capable hardware, optional cloud backends such as Google Gemini, OpenAI, or a self-hosted Ollama server can be connected with a single toggle.)

🎨 Bidirectional Code & Canvas Synchronization

One of the biggest frustrations with visual diagram tools is vendor lock-in. SysVis.AI solves this by keeping a live bidirectional link between code and canvas:

┌──────────────────────────────────────┬─────────────────────────────────────────────────┐
│ 📝 Monaco Editor (Bidirectional)     │ 🎨 Interactive Canvas (XY Flow + Dagre)         │
│                                      │                                                 │
│ graph TD                             │     ┌──────────────┐                            │
│   Client[API Gateway]                │     │ API Gateway  │                            │
│   Client --> Auth[Auth Service]      │     └──────┬───────┘                            │
│   Client --> Cache[(Redis Cluster)]  │            │                                    │
│   Client --> DB[(PostgreSQL)]        │     ┌──────▼───────┐      ┌─────────────────┐   │
│                                      │     │ Auth Service │ ───▶ │ Redis (In-Mem)  │   │
│                                      │     └──────────────┘      └─────────────────┘   │
│                                      │            │                                    │
│                                      │     ┌──────▼───────┐                            │
│                                      │     │  PostgreSQL  │                            │
│                                      │     └──────────────┘                            │
└──────────────────────────────────────┴─────────────────────────────────────────────────┘

Edit Code: Update your Mermaid syntax in the embedded Monaco editor, and the visual canvas updates in real time.
Drag & Rewire: Drag nodes, rewire edge connectors, or resize components on the XY Flow canvas, and the Monaco text updates automatically.
Self-Healing Auto-Layout: Powered by the Dagre layout engine, automatically resolving collision detection, orthogonal wire routing, and proper hierarchy layering with one click.

📤 Rich Export Options

When your architecture diagram is ready, you can export it in multiple developer-friendly formats:

Mermaid Markdown: Ready to paste into GitHub READMEs, Notion, or internal wikis.
React Flow Component: Export the diagram as standalone, fully typed React code with components and CSS that can be dropped straight into your web app.
Vector SVG & 3x High-Res PNG: Crisp, transparent renders perfect for slide decks and enterprise documentation.
Full JSON State: Import and resume your canvas state at any time.

🚀 Quick Start with Docker

You can run SysVis.AI locally or self-host it on your homelab with Docker:

docker run -d \
  --name sys-arc-visl \
  -p 5173:5173 \
  vndangkhoa/sys-arc-visl:latest

Navigate to http://localhost:5173 and start creating production-grade system diagrams right away.

🔗 Check it Out on GitHub

SysVis.AI is open-source under the MIT license:

⭐ GitHub Repository: https://github.com/vndangkhoa/Sys-Arc-Visl

🐳 Docker Hub: vndangkhoa/sys-arc-visl

Try it out with your next system design or whiteboard session!

Zero-Disk YouTube Downloader: How I Used Rust & Linux Kernel FIFOs for High-Throughput Streaming

Khoa.Vo — Wed, 23 Sep 2026 12:27:39 +0000

Zero-Disk YouTube Downloader: How I Used Rust & Linux Kernel FIFOs for High-Throughput Streaming

Most self-hosted YouTube and media downloaders (like MeTube, YoutubeDL-Material, or standard wrapper scripts) follow the same sequential workflow:

Client submits a URL.
Server spawns yt-dlp to download the entire video track and audio track onto the server's hard drive or SSD.
Server executes ffmpeg to mux both files into an .mp4 container on disk.
Server serves the resulting file to the client browser over HTTP.
A background cleanup job eventually deletes the temporary file from disk.

While straightforward, this approach has fatal drawbacks for homelabs and small VPS instances:

Severe Disk Wear: Downloading 4K or 1080p60 videos creates gigabytes of redundant read/write cycles on your host SSD.
Latency Delay: The user must wait until the entire media file finishes downloading and transcoding on the server before the browser download even begins.
YouTube Throttling: Unoptimized single-stream downloads frequently get throttled down to sluggish speeds.

I built KV-DL to rethink this pipeline from the ground up.

⚡ The Solution: The Zero-Disk Kernel FIFO Pipeline

KV-DL does not write a single byte of video or audio to your server's storage. Everything is streamed in-memory and multiplexed in real-time through Linux kernel named pipes (FIFOs):

yt-dlp (Video Stream) ──▶ FIFO #1 ─┐
                                   ├──▶ ffmpeg (RAM Muxer) ──▶ Fragmented MP4 ──▶ Browser Client
yt-dlp (Audio Stream) ──▶ FIFO #2 ─┘

Here is how the end-to-end data flow works:

Format Resolution: When the user enters a video or playlist URL, the Rust backend queries yt-dlp in JSON mode to extract title, thumbnail, and stream bitrate options.
Named Pipe Creation: Upon download request, the backend creates two temporary POSIX FIFOs (mkfifo) inside a volatile in-memory filesystem (/dev/shm or RAM).
Concurrent Stream Feeding: yt-dlp fetches high-speed HTTP chunk ranges from YouTube and pipes raw H.264/AV1 video into FIFO #1 and AAC/Opus audio into FIFO #2.
On-the-Fly Multiplexing: ffmpeg reads directly from both FIFOs simultaneously. It merges the video and audio containers without re-encoding (-c copy) and emits fragmented MP4 (-movflags frag_keyframe+empty_moov) directly to stdout.
Streaming HTTP Response: The Rust Axum web framework streams stdout directly into the HTTP response body as chunked transfer encoding (Transfer-Encoding: chunked).

Why Fragmented MP4?

Standard MP4 files require an index atom (moov atom) positioned at the beginning of the file, which usually requires knowing the exact file size after completion. By using fragmented MP4 (frag_keyframe), chunks can be transmitted to the browser incrementally the moment they are muxed, allowing the client's browser download to start in under 2 seconds!

🍪 In-Memory HMAC Cookie Vault

With YouTube increasingly restricting unauthenticated requests or triggering bot verification, maintaining valid session cookies is essential.

KV-DL includes a frictionless Cookie Vault:

Users can paste standard Netscape cookies.txt, JSON exports, or raw HTTP headers directly into the web UI.
Cookies are stored purely in volatile RAM, authenticated with an HMAC session key, and injected into yt-dlp requests on the fly.
Sensitive credentials are never persisted to disk or plain-text logs.

🔄 Frictionless Domain Swapping

To make downloading effortless, KV-DL supports universal domain swap routing. If you're browsing YouTube and see a video you want to grab, simply replace youtube.com in your address bar with your self-hosted KV-DL domain:

https://www.youtube.com/watch?v=dQw4w9WgXcQ
             ↓↓↓
https://dl.yourdomain.com/watch?v=dQw4w9WgXcQ

The video loads automatically in KV-DL, pre-populated with quality presets and instant download triggers.

🚀 Running KV-DL with Docker

KV-DL is packaged as a single lightweight multi-arch Docker container including the compiled Rust binary, embedded Next.js static UI, yt-dlp, and ffmpeg:

docker run -d \
  --name kv-dl \
  -p 3000:3000 \
  vndangkhoa/kv-dl:latest

Open http://localhost:3000 to start downloading media at full network speed with zero server disk wear.

🔗 Check it Out on GitHub

KV-DL is 100% open-source under the MIT license:

⭐ GitHub Repository: https://github.com/vndangkhoa/kv-dl

🐳 Docker Hub: vndangkhoa/kv-dl

Try it out on your server or homelab!

Building KV Files: A Blazing-Fast Web File Manager with macOS Miller Columns in Rust & React

Khoa.Vo — Wed, 23 Sep 2026 12:27:35 +0000

Building KV Files: A Blazing-Fast Web File Manager with macOS Miller Columns in Rust & React

Self-hosting a private file manager should be effortless. Yet most homelab users find themselves trapped in an awkward dilemma:

Monolithic Cloud Suites (e.g. Nextcloud): Incredible feature breadth, but notoriously heavy—demanding 500MB+ idle RAM, PHP runtimes, Redis caches, background cron workers, and database containers.
Minimalist Directory Viewers: Extremely lightweight, but lacking keyboard ergonomics, responsive media handling, and intuitive multi-depth navigation.

I wanted something that felt as fast and refined as macOS Finder's Miller Columns and as functional as Windows Explorer dual-pane Commander, while consuming virtually zero resources on my home server.

That is why I created KV Files (kv-file).

⚡ What Makes KV Files Different?

1. Cascading macOS Miller Columns

Instead of clicking back and forth through nested directories, KV Files renders cascading folder columns side-by-side with smooth horizontal scrolling.

┌────────────────────────────────────────────────────────────────────────────────────────┐
│ [≡] 🔍 Quick Search (Ctrl+K)   [ /storage/photos/2026/vacation ] [⟳]   [Columns ▾] [⚙]│
├───────────────┬──────────────────┬──────────────────┬──────────────────┬───────────────┤
│ 📂 STORAGE    │ 📁 2024          │ 📁 Summer        │ 🖼️ beach.jpg      │ 🖼️ beach.jpg  │
│  ├─ photos    │ 📁 2025          │ 📁 Roadtrip      │ 🖼️ sunset.png     │ 3.2 MB • JPEG │
│  ├─ documents │ 📁 2026 ──▶      │ 📁 Mountain      │ 🎥 vlog.mp4      │ 4032 x 3024   │
│  └─ backups   │                  │ 📁 Vacation ──▶  │ 📄 notes.txt     │ [Open] [Share]│
│               │                  │                  │                  │ [Download]    │
└───────────────┴──────────────────┴──────────────────┴──────────────────┴───────────────┘

You can navigate your entire disk using just arrow keys:

↑ / ↓: Move selection up and down.
→: Expand folder into a fresh column.
←: Back out to the parent column.
Space: Instant Quick Look preview for photos, 4K videos, markdown notes, code syntax highlighting, and PDFs.

2. Dual-Pane Commander Mode (`Alt + S`)

Need to organize and transfer files across different directories or drives? Press Alt + S to split the viewport into two synchronized panes. You can compare directories and copy (F5) or move (F6) files instantly.

3. Pure Rust (Axum + Tokio) Backend (~15 MB RAM)

The backend is written in Rust using the asynchronous Axum framework. It embeds the entire compiled React PWA frontend and an embedded SQLite database configured in WAL mode:

Idles at roughly 15 MB of RAM.
Saturates 10Gbps Ethernet links with non-blocking async I/O.
Deploys as a single, standalone binary or Docker container.

4. Sub-Millisecond Real-Time Kernel Sync (`inotify` + WebSockets)

If files are added, modified, or removed on the host filesystem—whether via an SSH terminal session, an rsync script, or automated torrent downloaders—the Linux kernel's inotify subsystem fires an event. KV Files broadcasts this change over WebSockets to all connected browser tabs in milliseconds. No polling, no manual page refreshes.

5. Native Lockscreen Media Streaming (W3C Media Session)

When streaming music or video from your server, KV Files interfaces directly with the browser's W3C Media Session API:

Full lockscreen controls on iOS (including the Dynamic Island).
Rich notifications with album artwork and scrubbers on Android.
Hardware media keys support on macOS and Windows keyboards.

6. Intelligent NAS Detection

KV Files automatically inspects filesystem mounting points and applies contextual badging for common homelab environments:

Synology DSM: Automatically hides @eaDir indexing artifacts and highlights shared folders.
TrueNAS: Badges ZFS dataset pools.
Unraid: Flags user shares and cache disks.
"Simple Mode": A toggle switch designed for non-technical family members that hides internal system directories and dotfiles.

🚀 Quick Start with Docker

Deploy KV Files in under 30 seconds using Docker:

docker run -d \
  --name kv-file \
  -p 8080:8080 \
  -v /your/storage/path:/data \
  -v ./kv-file-data:/config \
  vndangkhoa/kv-file:latest

Open http://localhost:8080 and start exploring your storage at lightning speed.

🔗 Check it Out on GitHub

KV Files is completely open source under the MIT license:

⭐ GitHub Repository: https://github.com/vndangkhoa/kv-file

🐳 Docker Hub: vndangkhoa/kv-file

Give it a spin on your server or NAS and let me know your thoughts!

Why I Built a Zero-Underline Vietnamese IME for Linux in Rust

Khoa.Vo — Wed, 23 Sep 2026 12:27:30 +0000

Why I Built a Zero-Underline Vietnamese IME for Linux in Rust

Anyone who has used Linux in Vietnam knows the long-standing frustration of typing Vietnamese on desktop environments—especially with the widespread adoption of Wayland (GNOME, KDE Plasma, Hyprland, Sway).

Traditional Input Method Engines (IMEs) rely on a pre-edit buffer. While this works reasonably well on macOS or Windows, on Linux it often produces:

Flickering Underlines: Every keystroke shows an underlined temporary word that interrupts code auto-completion in VS Code, Neovim, and terminal emulators.
Clipboard Race Conditions: Many input methods simulate backspaces and paste transformed characters via the system clipboard, colliding with your actual clipboard history or password managers.
Broken English Words: When typing common English words containing Vietnamese key combinations (e.g., test, search, code), words often get mangled into unnatural accent marks unless manually disabled.

To fix these problems at the root, I built Viet+ (VietC): a modern, zero-latency, zero-underline Vietnamese IME written 100% in Rust.

⚡ The Architecture: Direct Virtual Keystroke Injection

Instead of hijacking the desktop text field with a pre-edit overlay, Viet+ operates directly at the device input layer:

[Hardware Keyboard]
       │
       ▼
 [Viet+ Engine (Rust)] ───► [Finite State Machine & Telex/VNI Rules]
       │
       ▼ (Direct Unicode via /dev/uinput or wtype)
[Target Application: Terminal, Browser, IDE]

1. Zero Underline (No Pre-Edit Buffer)

Viet+ processes keystrokes in-flight. Characters appear directly in your active application as real Unicode text. No ghost underlines, no flickering text frames, and no disruption to IDE autocomplete dropdowns.

2. Intelligent English Auto-Restoration

A common nuisance when typing bilingual technical documents is accidentally turning English words into accented Vietnamese (e.g. typing as becoming á, or format becoming fórmat).

Viet+ embeds an intelligent trie-based dictionary check. If you type an English word pattern, the engine automatically rolls back the diacritics and restores clean English text without requiring you to constantly hit Ctrl + Space or switch modes.

Nguyeenx DDawng Khoa   ➔   Nguyễn Đăng Khoa
Khoong cos gif quis    ➔   Không có gì quí
search for the test    ➔   search for the test  (Auto-Restored!)

3. Wayland & X11 First-Class Support

Viet+ is designed for modern Wayland compositors:

Wayland: Native virtual keyboard protocol integration via wtype and wl-clipboard.
X11: Seamless fallback using xdotool and X11 key injection.
Hyprland / Sway / GNOME / KDE: Tested across leading tiling and desktop window managers.

🦀 Why Rust?

Input methods require predictable microsecond latency. Every key press must be intercepted, checked against grammar state machines, and re-emitted before the user's next keystroke lands.

By using Rust:

Zero Garbage Collection: Predictable sub-millisecond response times.
Safe Memory Concurrency: Safe IPC communication between background daemons and system trays.
100% Test Coverage: Viet+ includes 151 unit tests validating complex Telex, VNI, tone placement rules, and edge-case word combinations.

🚀 1-Command Installation

You can install Viet+ on Arch Linux, Fedora, Ubuntu, Debian, or openSUSE with a single command:

curl -fsSL https://raw.githubusercontent.com/vndangkhoa/vietc/main/install.sh | bash

Once installed, start the background daemon:

vietc &

Toggle between Vietnamese and English modes effortlessly using Ctrl + Space (customizable).

🔗 Check it Out on GitHub

Viet+ is 100% open-source under the MIT license. If you're running Linux and want a smooth, native typing experience without UI clutter:

⭐ GitHub Repository: https://github.com/vndangkhoa/vietc

Feedback, issues, and PRs are warmly welcome!

DEV Community: Khoa.Vo

Engineering KV Files PRO: 3D CAD Viewports, Adobe PSD Parsers & Offline Ed25519 Licensing in Rust

Engineering KV Files PRO: 3D CAD Viewports, Adobe PSD Parsers & Offline Ed25519 Licensing in Rust

⚡ Key Commercial Capabilities

1. Universal 3D CAD & BIM Viewport

2. Adobe Creative Suite Layer Parser

3. Typography & Font Inspector Studio

4. 100% Offline Ed25519 Cryptographic Licensing

📦 Deployment

🔗 Learn More

Building a Mobile-First Social Media Video Downloader with Go and yt-dlp

Building a Mobile-First Social Media Video Downloader with Go and yt-dlp

🎬 Key Features

🚀 Quick Start with Docker

🔗 Check it Out on GitHub

Managing Synology NAS with AI: Building KV-Synology with a 42-Tool MCP Server

Managing Synology NAS with AI: Building KV-Synology with a 42-Tool MCP Server

🎛️ What is KV-Synology?

🤖 The AI Model Context Protocol (MCP) Server

🚀 Quick Start with Docker

🔗 Check it Out on GitHub

Building Ola: Anti-Leak DRM Video Review & Media Explorer for Synology NAS

Building Ola: Anti-Leak DRM Video Review & Media Explorer for Synology NAS

🛡️ What is Ola?

1. Forensic Anti-Leak DRM Video Player

2. Dual-Pane Studio File Manager

3. Zero-Config P2P Tunnels

4. Native Synology SPK & Docker

🚀 Quick Start with Docker

🔗 Check it Out on GitHub

KV-Music: Self-Hosted YouTube Music Streamer with Rust Axum, React 19 & Synced Lyrics

KV-Music: Self-Hosted YouTube Music Streamer with Rust Axum, React 19 & Synced Lyrics

🎧 What Makes KV-Music Special?

1. The Entire YouTube Music Catalog, Self-Hosted

2. Time-Synced Dynamic Lyrics

3. Multi-Device Pairing & Sync

4. High-Performance Rust (Axum) Backend

5. Native Android App (Kotlin)

🚀 Quick Start with Docker

🔗 Check it Out on GitHub

KV-Tidal: Bit-Perfect Audiophile Streaming & OpenSubsonic Server for Synology NAS

KV-Tidal: Bit-Perfect Audiophile Streaming & OpenSubsonic Server for Synology NAS

🎵 What Makes KV-Tidal Unique?

1. Bit-Perfect Studio Master Streaming

2. Built-in OpenSubsonic Server Protocol

3. Native Bundled Soulseek P2P Lossless Engine

4. Native Synology SPK + Docker Support

🚀 Quick Start with Docker

🔗 Check it Out on GitHub

KV-Tube: How I Built a Self-Hosted YouTube Alternative in a Single Docker Container

KV-Tube: How I Built a Self-Hosted YouTube Alternative in a Single Docker Container

🎬 What is KV-Tube?

🏗️ Architecture: Go Backend + Next.js Frontend in One Container

⚡ SponsorBlock Integration

🚀 Quick Start with Docker

🔗 Check it Out on GitHub

Designing a Procedural Tetris-Tiled Homelab Dashboard with a Zero-Dependency Backend

Designing a Procedural Tetris-Tiled Homelab Dashboard with a Zero-Dependency Backend

🕹️ The Procedural Tetris Layout Engine

How the Layout Solver Works:

🔒 Hardened Zero-Dependency Node.js Backend

Built-in RFC 6238 TOTP 2FA

🛠️ Live In-Place Admin Mode (Ctrl + Shift + A)

🚀 Quick Start with Docker

🔗 Check it Out on GitHub

SysVis.AI: Running Architecture Diagramming AI 100% Locally in the Browser with WebGPU

SysVis.AI: Running Architecture Diagramming AI 100% Locally in the Browser with WebGPU

🔮 The Core Concept: Local-First In-Browser AI

🎨 Bidirectional Code & Canvas Synchronization

📤 Rich Export Options

🚀 Quick Start with Docker

🔗 Check it Out on GitHub

Zero-Disk YouTube Downloader: How I Used Rust & Linux Kernel FIFOs for High-Throughput Streaming

Zero-Disk YouTube Downloader: How I Used Rust & Linux Kernel FIFOs for High-Throughput Streaming

⚡ The Solution: The Zero-Disk Kernel FIFO Pipeline

Why Fragmented MP4?

🍪 In-Memory HMAC Cookie Vault

🔄 Frictionless Domain Swapping

🚀 Running KV-DL with Docker

🔗 Check it Out on GitHub

🛠️ Live In-Place Admin Mode (`Ctrl + Shift + A`)

2. Dual-Pane Commander Mode (`Alt + S`)

4. Sub-Millisecond Real-Time Kernel Sync (`inotify` + WebSockets)