Necrovault

An on-premise AI archeology skill for UGREEN NAS that resurrects unreadable legacy creative files into secure, interactive WebAssembly runtimes with zero cloud data leaks.

Comment

Inspiration

Millions of creative projects, historic digital assets, and enterprise archives are trapped inside dead technology. From 1990s Macromedia Flash (.swf) animations and Director (.dxr) interactives to obsolete layout binaries, modern operating systems simply refuse to open them. When creators and archivists back up legacy hard drives to their NAS, these files become digital fossils—dormant, unreadable cold storage. Cloud conversion tools fail because they cannot execute vintage binaries, enforce strict file-size limits, and pose massive privacy and compliance risks for proprietary client work.

We asked: What if your NAS was more than passive storage? What if it could autonomously perform binary archeology, understand raw byte structures, and bring dead files back to life locally? That question birthed NecroVault.

What it does

NecroVault is an autonomous, on-premise binary archeology engine and runtime preservation skill designed for UGREEN AI NAS.

  • Autonomous Cold Storage Ingest: Watches designated storage pools for incoming legacy drives, disc dumps, or archived folders.
  • Shannon Entropy & Magic Forensics: Bypasses superficial file extensions to analyze raw byte density. It calculates Shannon entropy (0.0 to 8.0) to mathematically differentiate raw executable logic from compressed multimedia streams.
  • Cognitive Asset Reconstruction: Uses local AI agents to inspect broken header offsets, extract embedded raster and vector streams, and synthesize modern rendering instructions.
  • Sandboxed WebAssembly Resurrection: Recompiles the extracted asset into a secure, standalone WebAssembly (.wasm) binary wrapped in a self-contained HTML5 player.
  • Instant Preview in UGOS: Creative directors and editors can immediately interact with and review previously dead media directly inside their UGOS desktop browser—without installing vintage software or exposing sensitive assets to the cloud.

How we built it

We designed NecroVault with a strict, two-stage architectural roadmap: a validated local systems core for Round 1, and native hardware orchestration for Round 2.

What is Built and Verified for Round 1:

  • The Hexagonal Go Core: We implemented the entire core domain logic in Go using strict Ports & Adapters. The domain has zero external dependencies and handles raw byte reading, magic signature detection, and Shannon entropy calculations.
  • Property-Based Verification: We wrote automated property-based test suites using Go’s testing/quick, running 2,000 randomized iterations to mathematically prove memory safety, non-panicking boundary checks, and bounded entropy math on corrupt binaries.
  • The MCP & IPC Tooling: We built the driving MCP (Model Context Protocol) server over standard JSON-RPC and an outbound TCP socket bridge, enabling our reasoning agent to query byte slices and telemetry on demand.
  • Wasm Generation Prototype: A minimal in-memory WebAssembly compiler adapter and retro CRT terminal interface that emits valid, sandboxed .wasm binaries.

Planned for Round 2 (Finalist NAS Access):

  • Native UGOS Service Daemon: Packaging the engine to hook directly into UGOS system-level file-event notifications (inotify / UGOS watcher API).
  • Skills Hub Integration: Connecting the output pipeline to UGREEN Skills Hub for one-click deployment directly within the NAS desktop environment.

Challenges we ran into

  • Preventing Buffer Overflows on Corrupt Files: Real-world legacy files are frequently truncated, bit-rotted, or corrupted. Initial naive byte-slicing logic risked panic errors or out-of-bounds reads. We solved this by implementing Property-Based Testing (PBT) using Go’s testing/quick, running 1,000 randomized byte variations to mathematically guarantee slicing invariants and non-panicking error returns.
  • Entropy Distribution Ambiguity: Distinguishing between heavily compressed assets (like zlib streams inside Flash SWF containers) and encrypted byte blocks required fine-tuning our Shannon entropy heuristics to accurately classify files above the 7.1 threshold.
  • Zero-Cloud Performance: Ensuring the pipeline operated completely offline required writing our own minimal WebAssembly binary header serializer rather than leaning on heavy, cloud-based compiler toolchains.

Accomplishments that we're proud of

  • Rock-Solid Domain Purity: Built a completely decoupled Hexagonal architecture where the core domain logic has zero external dependencies and 100% test pass rates across 2,000 property-based iterations.
  • True End-to-End Resurrection: Watching a completely dead, unplayable 2000s vector container get dissected by the Go engine and instantly boot up into an interactive 60fps canvas widget in the browser.
  • Zero Data Egress: Achieving complete binary archeology and visual recovery with zero bytes sent to external third-party cloud APIs.

What we learned

  • The Power of Spec-Driven Hexagonal Design: Defining inbound and outbound ports before writing adapter code eliminated cross-language integration friction and made testing effortless.
  • Local Hardware Beats Cloud SaaS for Archival: Modern NAS hardware (like the UGREEN AI NAS iDX6011 Pro) provides massive bus speeds and local compute that make scanning multi-gigabyte cold storage archives vastly faster and cheaper than cloud-upload pipelines.

What's next for Necrovault

Our immediate roadmap focuses on capitalizing on the 1-day remote UGREEN AI NAS iDX6011 Pro hardware access during Round 2:

  1. Deploying Native UGOS Daemons: Porting our local socket and storage adapters to interface directly with native UGOS system APIs, enabling automated background crawling of shared NAS volumes.
  2. Hardware I/O Stress-Testing: Benchmarking multi-gigabyte batch extraction on real NVMe cache and RAID storage pools to tune CPU nice-levels and prevent interference with primary NAS file-serving tasks.
  3. Local LLM Model Integration: Connecting the reasoning bridge directly to the onboard UGREEN AI engine to test local parameter-efficient models (e.g., quantized Whisper and small VLMs) for automated media tagging and asset restoration.
  4. UGOS Skills Hub Packaging: Finalizing the complete one-click installer, settings UI, and dashboard widgets for the UGREEN Skills Hub marketplace.

Built With

Share this project:

Updates

Submission history