Retrigger

High-Performance File System Watcher for Modern Development Workflows

Retrigger is a native file system monitoring daemon designed to eliminate the performance bottlenecks in development tooling. By replacing slow JavaScript-based file watchers with a multi-language native implementation, Retrigger delivers 100-160x faster hot reload times for modern web development workflows.

What Retrigger Does

Retrigger monitors your project files and instantly detects changes with sub-millisecond latency. When you save a file, the system:

• Detects the change through kernel-level file system events
• Computes optimized hashes using SIMD-accelerated algorithms
• Maintains an in-memory cache of file states
• Notifies development tools (webpack, Vite, etc.) through zero-copy IPC
• Triggers rebuilds in under 5ms instead of the typical 500-2000ms

Why I Built Retrigger

Modern development workflows suffer from a fundamental performance problem: file watching. JavaScript-based watchers like Chokidar are convenient but prohibitively slow on large codebases. When working with projects containing 10,000+ files, developers experience:

• Hot reload delays of 1-2 seconds per change
• High CPU usage from constant polling
• Development workflow interruptions
• Reduced productivity and developer satisfaction

Retrigger solves this by leveraging native system capabilities and advanced algorithms that JavaScript cannot access efficiently. The result is a development experience that feels instant rather than sluggish.

System Architecture

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   File System   │    │  Retrigger      │    │  Development    │
│    Changes      │    │    Daemon       │    │     Tools       │
└─────────────────┘    └─────────────────┘    └─────────────────┘
         │                       │                       │
         │ inotify/FSEvents      │                       │
         ├──────────────────────►│                       │
         │                       │                       │
         │                    ┌──▼──────────────────┐    │
         │                    │  System Watcher     │    │
         │                    │  (Zig/C)           │    │
         │                    └──┬──────────────────┘    │
         │                       │                       │
         │                    ┌──▼──────────────────┐    │
         │                    │  Hash Engine        │    │
         │                    │  (SIMD-optimized)   │    │
         │                    └──┬──────────────────┘    │
         │                       │                       │
         │                    ┌──▼──────────────────┐    │
         │                    │  Cache & IPC        │    │
         │                    │  (Rust daemon)      │    │
         │                    └──┬──────────────────┘    │
         │                       │                       │
         │                    ┌──▼──────────────────┐    │
         │                    │  Node.js Bindings   │    │
         │                    │  (Zero-copy IPC)    │    │
         │                    └──┬──────────────────┘    │
         │                       │                       │
         │                       │ Plugin Interface      │
         │                       ├──────────────────────►│
         │                       │                       │
         │                   <5ms latency              webpack
         │                                             Vite
         │                                             Rspack

Key Features

Performance

• Sub-5ms file change detection and notification
• SIMD-accelerated hashing (AVX-512, AVX2, NEON)
• Zero-copy IPC using shared memory
• Incremental hashing for partial file updates

System Integration

• Native kernel integration (inotify, FSEvents, ReadDirectoryChangesW)
• eBPF support for advanced filtering
• io_uring for zero-copy file operations on Linux
• Hot-reloadable configuration without daemon restart

Developer Experience

• Drop-in webpack/Vite plugin integration
• TypeScript definitions included
• Comprehensive metrics and monitoring
• Cross-platform support (Linux, macOS, Windows)

Performance Benchmarks

Getting Started

Installation

# Install the daemon
cargo install retrigger-daemon

# Install Node.js bindings
npm install @retrigger/webpack-plugin

Configuration

// webpack.config.js
const RetriggerPlugin = require('@retrigger/webpack-plugin');

module.exports = {
  plugins: [
    new RetriggerPlugin({
      // Plugin automatically connects to running daemon
    })
  ]
};

Running the Daemon

# Start the daemon
retrigger start --config retrigger.toml

# Generate default configuration
retrigger config --output retrigger.toml

# Check daemon status
retrigger status

# Run performance benchmarks
retrigger benchmark --files 10000

Technical Implementation

Retrigger implements a multi-layer architecture optimized for performance:

1. Core Hash Engine (C): SIMD-optimized XXH3 implementation with AVX-512/NEON support
2. System Integration (Zig): Zero-overhead bindings to kernel file system APIs
3. Daemon Logic (Rust): Async runtime with tokio, concurrent hash caching, gRPC server
4. Node.js Bindings: NAPI-RS based bindings with SharedArrayBuffer communication

The system maintains compatibility with existing development tools while providing dramatic performance improvements through native optimization and advanced system programming techniques.

License

MIT License - see LICENSE file for details.

Contributing

Contributions are welcome. Please read CONTRIBUTING.md for guidelines on submitting pull requests and reporting issues.