Frankenstein Soul Collector

A monstrous chimera stitching together Rust's raw power with web magic, wrapped in a haunting CRT interface that'll give your CPU nightmares.

Comment

Project Story: Frankenstein Soul Collector

What Inspired Me

I was working on a Rust application that needed system monitoring capabilities, but I faced a classic dilemma: how do you monitor system resources without becoming the performance bottleneck yourself? Traditional monitoring tools are often resource-heavy, written in interpreted languages, or lack memory safety guarantees. I wanted something that could collect metrics with minimal system impact while being modern, safe, and... well, fun to look at.

The Halloween hackathon theme sparked an idea: what if system monitoring didn't have to be boring? What if watching your CPU usage could feel like you're Neo looking at the Matrix code? That's when the concept of "soul collecting" was born - gathering the vital essence of your system in the most haunting way possible.

What I Learned

This project became a masterclass in bridging incompatible worlds:

The Rust-CLI-Web Reality

  • Rust's Zero-Cost Abstractions: Learning how sysinfo provides cross-platform system metrics with minimal overhead
  • WASM Limitations: Discovering that WebAssembly's browser security model prevents direct system access - great for computation, not for system monitoring
  • Unix Philosophy Wins: Understanding that sometimes the best architecture is the simplest - excellent CLI tools composed with lightweight bridges

Dual Interface Design

  • CLI Excellence: Building a fast, scriptable command-line tool that power users actually want to use
  • Web UI Polish: Creating a haunting retro interface for visual monitoring without compromising the CLI's performance
  • Data Flow Architecture: Learning how to stream real-time system data from Rust through Node.js to React efficiently

Kiro's Development Superpowers

  • Spec-Driven Development: Using Kiro's specs to structure complex multi-language projects
  • Steering Documents: Leveraging project-specific guidance to maintain consistency across Rust and TypeScript codebases
  • Vibe Coding/Agentic Coding: Natural conversation with Kiro to iterate on both technical architecture, manually evaluating the usage of the tool to provide feedback and aesthetic details on the UI

How I Built It

The Frankenstein Evolution

This project truly embodies the "Frankenstein" category - but not in the way I originally planned. It started as an ambitious WASM experiment and evolved into something more practical:

Phase 1: The WASM Dream

  1. Rust Core (soul-core-cli/): High-performance system metrics collection using sysinfo, tokio for async operations, and clap for CLI interface
  2. WASM Bridge Attempt: Initially tried compiling Rust to WebAssembly with wasm-pack and wasm-bindgen
  3. Reality Check: Hit WASM limitations - browser security restrictions prevented direct system access, and the complexity wasn't worth the theoretical performance gains

Phase 2: The Practical Pivot

  1. Standalone CLI Excellence: Focused on making the Rust CLI tool exceptional - fast, reliable, with beautiful terminal output
  2. Node.js Web Server (soul-web-server/): Built a lightweight Express server that spawns the CLI tool and streams JSON data
  3. React Frontend (soul-collector-web/ui/): Haunting CRT-styled interface that consumes real system data via WebSocket connections
  4. Dual Mode Architecture: CLI for power users and automation, web UI for visual monitoring and that retro aesthetic

Development Workflow with Kiro

Spec-Driven Foundation: Started with comprehensive specs defining the dual CLI/web architecture, FFI protocols, and aesthetic requirements. This gave Kiro the context to maintain consistency across the entire codebase.

Steering for Consistency: Created steering documents for:

  • FFI protocol enforcement between Rust and TypeScript
  • Project-local configuration (no global tool pollution)
  • Aesthetic guidelines ensuring consistent CRT effects
  • Technology stack best practices

Vibe Coding for Iteration: Used natural conversation with Kiro to:

  • Refine the haunting aesthetic details (scanline opacity, phosphor glow intensity)
  • Navigate the WASM pivot and redesign the architecture
  • Optimize CLI performance and web server data streaming

Technical Implementation

The CLI Core (What Actually Works)

// Rust CLI: Direct system access, no compromises
pub fn collect_system_metrics() -> Result<SystemMetrics, CollectionError> {
    let mut system = System::new_all();
    system.refresh_all();

    Ok(SystemMetrics {
        cpu_usage: system.cpus().iter().map(|cpu| cpu.cpu_usage()).collect(),
        memory: MemoryMetrics::from_system(&system),
        processes: collect_process_metrics(&system)?,
    })
}

The Web Bridge (What Actually Ships)

// Node.js server: Spawn CLI and stream data
const cliProcess = spawn("./soul-core-cli", [
  "monitor",
  "--json",
  "--interval",
  "1000",
]);
cliProcess.stdout.on("data", (data) => {
  const metrics = JSON.parse(data.toString());
  wss.clients.forEach((client) => client.send(JSON.stringify(metrics)));
});

The Haunting Interface

/* CRT effects that actually enhance the experience */
.crt-screen {
  animation: screen-flicker 0.02s infinite;
  text-shadow: 0 0 10px var(--phosphor-glow);
  background: radial-gradient(
    ellipse at center,
    transparent 0%,
    rgba(0, 0, 0, 0.4) 100%
  );
}

Challenges I Faced

The WASM Reality Check

Challenge: WASM seemed perfect for bridging Rust performance with web interfaces, but browser security models prevent direct system access. Solution: Pivoted to a hybrid architecture - keep the high-performance Rust CLI for direct system access, use Node.js as a bridge to the web.

Architecture Pivot Mid-Development

Challenge: Abandoning the WASM approach meant rethinking the entire data flow and communication strategy. Solution: Embraced the Unix philosophy - make the CLI tool excellent at one thing, then compose it with other tools. The web server simply orchestrates the CLI and streams data.

Dual Interface Excellence

Challenge: Making both the CLI and web interface first-class experiences rather than one being a compromise. Solution: Made the CLI the source of truth with beautiful terminal output AND JSON mode. The web UI consumes the same data that power users can pipe and process.

Real-Time Streaming Without Overhead

Challenge: Streaming system metrics to a web interface without the CLI becoming a performance bottleneck. Solution: Optimized the CLI for efficient JSON output, implemented smart polling intervals, and used WebSockets for low-latency data streaming.

Aesthetic Authenticity

Challenge: Creating authentic CRT effects that enhance rather than distract from system monitoring. Solution: The web UI feels like a retro terminal with subtle scanlines and phosphor glow, while the CLI stays clean and scriptable - each interface serves its audience.

The Kiro Advantage

This project showcased Kiro's unique strengths:

  • Multi-Language Fluency: Seamlessly switching between Rust systems programming and React frontend development
  • Architecture Guidance: Helping design the FFI protocol and project structure through natural conversation
  • Consistency Enforcement: Using steering documents to maintain code quality across different technology stacks
  • Rapid Iteration: Vibe coding allowed quick aesthetic refinements and performance optimizations

The result is a monitoring tool that's both technically robust and visually haunting - proving that system utilities don't have to be boring, and that the right development partner can help you build something truly monstrous in the best possible way.

Built With

Share this project:

Updates