RuVector Memory Optimizer

Make your Windows PC faster by freeing up memory automatically.

Your computer slows down when too many programs use up RAM. RuVector MemOpt watches your memory and cleans it up automatically - like having a tiny helper that keeps your PC running smooth.

What's New in v0.3.0

• AI Mode - GPU/VRAM monitoring for AI workloads (Ollama, llama.cpp, PyTorch)
• Game Mode - Auto-detects games and optimizes for gaming performance
• Focus Mode - Detects video calls (Zoom, Teams) and prioritizes them
• System Tray Enhancements - New settings menu, threshold controls, GitHub link
• Console-Free Tray - Dedicated tray binary that runs without a console window

What It Does

• Frees memory when your PC gets slow
• Learns your habits to optimize at the right time
• Runs quietly in your system tray
• Shows you exactly how much memory it freed

Quick Start

Option 1: Installer (Recommended)

1. Download RuVectorMemOptSetup.exe from Releases
2. Run the installer
3. Launch "RuVector MemOpt" from Start Menu
4. Look for the green icon in your system tray (bottom-right)

Option 2: Portable (No Install)

1. Download RuVectorMemOpt.exe from Releases
2. Open Command Prompt or PowerShell
3. Navigate to where you downloaded it: cd Downloads
4. Run: RuVectorMemOpt.exe tray
5. Look for the green icon in your system tray

Tip: Can't find the tray icon? Click the ^ arrow in the bottom-right to show hidden icons.

What You'll See

When you right-click the tray icon:

• Memory status (updates every few seconds)
• Optimize Now - free memory instantly
• Deep Clean - more aggressive optimization
• AI Mode - Configure AI workload optimization
  • Game Mode Auto-Detect
  • Focus Mode Auto-Detect
  • Thermal Prediction
  • Predictive Preloading
• Settings - Customize optimization thresholds (75%, 80%, 85%, 90%)
• System Info - see your CPU capabilities
• GitHub Repository - Quick link to project page

How Much Memory Does It Free?

Real test on Windows 11:

Your mileage may vary, but most users see 1-6 GB freed per optimization.

How Much Faster Will My PC Be?

Real Speed Improvements

Why Does Freeing RAM Make Things Faster?

When your RAM fills up, Windows starts using your hard drive as backup memory (called "paging"). Hard drives are 1000x slower than RAM. By keeping RAM free, your PC stays in "fast mode" instead of "slow hard drive mode."

Who Benefits Most?

Bottom line: If your PC ever feels slow, this helps. The less RAM you have, the more you'll notice.

Commands

Open Command Prompt and run:

# Basic Commands
ruvector-memopt status              # Check your memory
ruvector-memopt optimize            # Free memory now
ruvector-memopt optimize --aggressive  # Deep memory cleanup
ruvector-memopt optimize --dry-run  # Preview without changes
ruvector-memopt tray                # Start tray icon
ruvector-memopt daemon              # Continuous background optimization
ruvector-memopt daemon -i 30        # Custom interval (30 seconds)
ruvector-memopt startup             # One-time startup optimization
ruvector-memopt cpu                 # Show CPU/SIMD info
ruvector-memopt dashboard           # Live memory view
ruvector-memopt config              # Show current configuration

# Advanced Analysis (RuVector Algorithms)
ruvector-memopt pagerank            # Process importance ranking
ruvector-memopt clusters            # MinCut process clustering
ruvector-memopt patterns --duration 30  # Spectral pattern analysis
ruvector-memopt bench --advanced    # Run algorithm benchmarks
ruvector-memopt dashboard-server    # Start JSON API dashboard

Tray Icon Colors

The system tray icon changes color based on memory usage:

The icon also shows a fill level indicator representing current memory usage.

Why Is This Better Than Other Memory Cleaners?

AI Mode (v0.3.0)

RuVector now includes intelligent AI workload support for users running local LLMs, machine learning, or GPU-intensive applications.

Features

Enabling AI Mode

AI Mode is an optional feature. Install with AI features enabled:

# Install with AI features
cargo install ruvector-memopt --features ai

# Install with full AI features (including NVIDIA NVML)
cargo install ruvector-memopt --features ai-full

Placement Strategies

When running LLMs, RuVector can optimize model layer placement:

Supported AI Runtimes

• Ollama
• llama.cpp
• vLLM
• PyTorch / TensorFlow
• ONNX Runtime
• RuVLLM (RuVector's LLM runtime)

System Requirements

• Windows 10 or 11
• 4 GB RAM minimum
• Works without admin (admin unlocks more features)
• For AI Mode: NVIDIA GPU recommended (AMD/Intel supported with limited features)

For Developers

Build from Source

git clone https://github.com/ruvnet/optimizer
cd optimizer

# Build all binaries
cargo build --release

# Build with AI features
cargo build --release --features ai

# Build with full AI features (NVIDIA NVML)
cargo build --release --features ai-full

Binaries Produced

Install from Crates.io

# Basic installation
cargo install ruvector-memopt

# With AI features
cargo install ruvector-memopt --features ai

# With full AI features (NVIDIA NVML support)
cargo install ruvector-memopt --features ai-full

Feature Flags

CPU Acceleration Detected

This optimizer automatically uses your CPU's special features:

Run RuVectorMemOpt.exe cpu to see what your system supports.

Safety

• Won't crash your PC - protected processes list
• Won't delete files - only frees memory
• Won't use internet - runs 100% locally
• Won't slow you down - optimizes in background

FAQ

Q: Will this break anything? A: No. It only asks Windows to free unused memory. Nothing is deleted.

Q: Do I need admin rights? A: No, but admin lets you clear more system caches.

Q: How is this different from Windows built-in memory management? A: Windows is conservative - it keeps lots of cache "just in case". This tool aggressively frees that cache when you actually need the RAM.

Q: Will it help my old PC? A: Yes! Older PCs with less RAM benefit the most.

Architecture

┌───────────────────────────────────────────────────────────────┐
│                    RuVector MemOpt v0.3.0                      │
├───────────────────────────────────────────────────────────────┤
│  CLI Interface  │  System Tray  │  Dashboard  │  Win Service  │
├───────────────────────────────────────────────────────────────┤
│                  Intelligent Optimizer Core                    │
│  ┌─────────────┐  ┌─────────────┐  ┌───────────────────────┐ │
│  │   Neural    │  │   Pattern   │  │    Process Scorer     │ │
│  │   Engine    │  │   Index     │  │  ┌─────────────────┐  │ │
│  │  (GNN/EWC)  │  │   (HNSW)    │  │  │ PageRank 11.47x │  │ │
│  └─────────────┘  └─────────────┘  │  └─────────────────┘  │ │
│                                     └───────────────────────┘ │
├───────────────────────────────────────────────────────────────┤
│                    AI Mode (Optional)                          │
│  ┌─────────────┐  ┌─────────────┐  ┌───────────────────────┐ │
│  │    GPU      │  │   Workload  │  │     Resource          │ │
│  │   Monitor   │  │   Detector  │  │     Bridge            │ │
│  │ (DXGI/NVML) │  │(Ollama/LLM) │  │  (CPU/GPU/NPU)        │ │
│  └─────────────┘  └─────────────┘  └───────────────────────┘ │
│  ┌─────────────┐  ┌─────────────┐                            │
│  │  Game Mode  │  │ Focus Mode  │  Auto-detect 40+ games     │
│  │  (Gaming)   │  │(Video Call) │  Zoom/Teams/Meet support   │
│  └─────────────┘  └─────────────┘                            │
├───────────────────────────────────────────────────────────────┤
│                    Advanced Algorithms                         │
│  ┌─────────────┐  ┌─────────────┐  ┌───────────────────────┐ │
│  │   MinCut    │  │  Count-Min  │  │     Spectral          │ │
│  │  Clustering │  │   Sketch    │  │     Analyzer          │ │
│  │   (Graph)   │  │  (O(1) ops) │  │  (Pattern Classify)   │ │
│  └─────────────┘  └─────────────┘  └───────────────────────┘ │
├───────────────────────────────────────────────────────────────┤
│  SIMD Acceleration (AVX2/AVX-512/AVX-VNNI)                    │
├───────────────────────────────────────────────────────────────┤
│                  Windows Memory APIs (Win32)                   │
│  SetProcessWorkingSetSizeEx │ GetProcessMemoryInfo │ DXGI    │
└───────────────────────────────────────────────────────────────┘

Key Components

• Neural Decision Engine: Uses attention mechanisms and pattern learning to decide optimal optimization timing
• HNSW Pattern Index: Fast similarity search for memory usage patterns
• EWC Learner: Elastic Weight Consolidation prevents forgetting successful strategies
• Process Scorer: Ranks processes by memory footprint for targeted optimization
• SIMD Optimizer: Hardware-accelerated vector operations for pattern matching

AI Mode Components (Optional)

• GPU Monitor: Real-time VRAM tracking via DXGI (all GPUs) or NVML (NVIDIA)
• AI Workload Detector: Identifies running AI runtimes (Ollama, PyTorch, etc.)
• Resource Bridge: Unified CPU/GPU/NPU resource allocation
• Game Mode: Auto-detects 40+ popular games for optimized gaming
• Focus Mode: Prioritizes video conferencing apps (Zoom, Teams, Meet)
• Ollama Client: Direct integration with Ollama API for model management

Smart Features (What Makes It Better)

RuVector doesn't just free memory randomly - it uses smart algorithms to decide what to optimize and when.

1. Smart Process Ranking (PageRank)

Ever wonder which programs are safe to trim? RuVector uses the same algorithm Google uses to rank web pages - but for your processes. It figures out which programs are important (like your browser) vs which are background junk.

Result: Frees more memory without breaking things. 11x faster at deciding what to optimize.

ruvector-memopt pagerank    # See which processes matter most

2. Process Grouping (MinCut)

Programs that work together should be optimized together. RuVector automatically groups related processes (like all your Chrome tabs) and handles them as a unit.

Result: 50% more memory freed because related programs get optimized together.

ruvector-memopt clusters    # See how your programs are grouped

3. Pattern Detection

RuVector learns your computer's memory patterns:

• Is memory slowly leaking? (potential memory leak)
• Does usage spike at certain times? (scheduled tasks)
• Is it stable? (no action needed)

Result: Optimizes at the right time, not just when memory is full.

ruvector-memopt patterns --duration 30    # Watch patterns for 30 seconds

4. Instant History Tracking

Remembers millions of memory events using almost zero memory itself. Knows if a problem happened before.

Result: Uses 98% less memory to track history than traditional methods.

Performance Benchmarks

We tested on Windows 11 with 100 runs each:

Bottom line: The smart features add almost no overhead while making optimization much more effective.

Run benchmarks yourself:

ruvector-memopt bench --advanced

Library Usage

Use RuVector MemOpt as a library in your Rust project:

use ruvector_memopt::{OptimizerConfig, IntelligentOptimizer};

#[tokio::main]
async fn main() {
    let config = OptimizerConfig::default();
    let mut optimizer = IntelligentOptimizer::new(config);

    // Evaluate and optimize if needed
    if let Ok(decision) = optimizer.evaluate().await {
        if decision.should_optimize {
            let result = optimizer.optimize(&decision).await.unwrap();
            println!("Freed {} MB", result.freed_mb);
        }
    }
}

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

License

MIT License - free to use, modify, share.

Made with Rust by ruv

A smarter way to keep your PC fast.