ruv-swarm-wasm

High-performance WebAssembly neural network orchestration with SIMD optimization for browser and Node.js environments.

Introduction

ruv-swarm-wasm is a cutting-edge WebAssembly implementation of the ruv-swarm neural network orchestration engine, specifically designed for maximum performance in web browsers and Node.js environments. By leveraging SIMD (Single Instruction, Multiple Data) optimizations and WebAssembly's near-native performance, this crate delivers unprecedented speed for neural network operations in JavaScript environments.

Key Features

⚡ WebAssembly Performance Optimization

• SIMD-accelerated operations: 2-4x performance improvement over scalar implementations
• Near-native performance: WebAssembly execution with optimized memory management
• Browser compatibility: Supports all modern browsers with WebAssembly SIMD
• Optimized bundle size: < 800KB compressed WASM module

🚀 SIMD Capabilities

• Vector operations: Dot product, addition, scaling with f32x4 SIMD registers
• Matrix operations: Optimized matrix-vector and matrix-matrix multiplication
• Activation functions: SIMD-accelerated ReLU, Sigmoid, and Tanh implementations
• Performance benchmarking: Built-in tools to measure SIMD vs scalar performance

🧠 Neural Network Operations

• Fast inference: < 20ms agent spawning with full neural network setup
• Parallel processing: Web Workers integration for true parallelism
• Memory efficiency: < 5MB per agent neural network
• Batch processing: Optimized for multiple simultaneous operations

🌐 Cross-Platform Compatibility

• Browser support: Chrome, Firefox, Safari, Edge with WebAssembly SIMD
• Node.js compatibility: Full support for server-side neural processing
• Mobile optimization: Efficient performance on mobile browsers
• TypeScript support: Complete type definitions included

Installation

Web Browser (ES Modules)

npm install ruv-swarm-wasm

import init, { 
    WasmSwarmOrchestrator, 
    SimdVectorOps, 
    SimdMatrixOps 
} from 'ruv-swarm-wasm';

// Initialize the WASM module
await init();

Node.js Environment

npm install ruv-swarm-wasm

import init, { 
    WasmSwarmOrchestrator, 
    SimdVectorOps 
} from 'ruv-swarm-wasm';

// Initialize with Node.js specific optimizations
await init();

CDN Usage (Browser)

<script type="module">
import init, { SimdVectorOps } from 'https://unpkg.com/ruv-swarm-wasm/ruv_swarm_wasm.js';

await init();
const vectorOps = new SimdVectorOps();
</script>

Usage Examples

Basic SIMD Vector Operations

import init, { SimdVectorOps } from 'ruv-swarm-wasm';

await init();

const vectorOps = new SimdVectorOps();

// High-performance vector operations
const vecA = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0];
const vecB = [2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0];

// SIMD-accelerated dot product (2-4x faster)
const dotProduct = vectorOps.dot_product(vecA, vecB);

// SIMD vector addition
const vectorSum = vectorOps.vector_add(vecA, vecB);

// SIMD activation functions
const reluResult = vectorOps.apply_activation(vecA, 'relu');
const sigmoidResult = vectorOps.apply_activation(vecA, 'sigmoid');

Neural Network Inference

import init, { WasmNeuralNetwork, ActivationFunction } from 'ruv-swarm-wasm';

await init();

// Create a high-performance neural network
const layers = [784, 256, 128, 10]; // MNIST-like architecture
const network = new WasmNeuralNetwork(layers, ActivationFunction.ReLU);
network.randomize_weights(-1.0, 1.0);

// Lightning-fast inference (< 5ms typical)
const input = new Array(784).fill(0).map(() => Math.random());
const output = network.run(input);

console.log('Classification result:', output);

Swarm Orchestration with Performance Monitoring

import init, { 
    WasmSwarmOrchestrator, 
    SimdBenchmark 
} from 'ruv-swarm-wasm';

await init();

// Create high-performance swarm orchestrator
const orchestrator = new WasmSwarmOrchestrator();

// Configure swarm for optimal performance
const swarmConfig = {
    name: "Performance Swarm",
    topology_type: "mesh",
    max_agents: 10,
    enable_cognitive_diversity: true,
    simd_optimization: true
};

const swarm = orchestrator.create_swarm(swarmConfig);

// Benchmark SIMD performance
const benchmark = new SimdBenchmark();
const dotProductBench = benchmark.benchmark_dot_product(10000, 100);
const activationBench = benchmark.benchmark_activation(10000, 100, 'relu');

console.log('SIMD Performance:', JSON.parse(dotProductBench));
console.log('Activation Performance:', JSON.parse(activationBench));

Advanced Matrix Operations

import init, { SimdMatrixOps } from 'ruv-swarm-wasm';

await init();

const matrixOps = new SimdMatrixOps();

// High-performance matrix operations
const matrix = new Float32Array([
    1.0, 2.0, 3.0,
    4.0, 5.0, 6.0
]); // 2x3 matrix

const vector = new Float32Array([1.0, 2.0, 3.0]);

// SIMD-optimized matrix-vector multiplication
const result = matrixOps.matrix_vector_multiply(matrix, vector, 2, 3);
console.log('Matrix-vector result:', result); // [14, 32]

// Matrix-matrix multiplication for neural layers
const matrixA = new Float32Array([1.0, 2.0, 3.0, 4.0]); // 2x2
const matrixB = new Float32Array([5.0, 6.0, 7.0, 8.0]); // 2x2
const matMulResult = matrixOps.matrix_multiply(matrixA, matrixB, 2, 2, 2);
console.log('Matrix multiplication:', matMulResult); // [19, 22, 43, 50]

Performance Benchmarks

SIMD vs Scalar Performance

Neural Network Inference Performance

Browser Compatibility

SIMD Feature Detection

import init, { detect_simd_capabilities } from 'ruv-swarm-wasm';

await init();

// Check runtime SIMD capabilities
const capabilities = JSON.parse(detect_simd_capabilities());
console.log('SIMD Capabilities:', capabilities);

// Example output:
// {
//   "simd128": true,
//   "feature_simd": true,
//   "runtime_detection": "supported"
// }

Building from Source

Prerequisites

# Install Rust and wasm-pack
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh

# Install Node.js dependencies
npm install

Build Commands

# Build optimized WASM module with SIMD support
wasm-pack build --target web --out-dir pkg --release

# Build for Node.js
wasm-pack build --target nodejs --out-dir pkg-node --release

# Build with specific SIMD features
RUSTFLAGS="-C target-feature=+simd128" wasm-pack build --target web

# Run performance tests
wasm-pack test --headless --chrome --release

Development Build

# Development build with debug symbols
wasm-pack build --target web --dev

# Run SIMD verification suite
./verify_simd.sh

API Reference

SimdVectorOps

High-performance SIMD vector operations:

• dot_product(a: Float32Array, b: Float32Array): number
• vector_add(a: Float32Array, b: Float32Array): Float32Array
• vector_scale(vec: Float32Array, scalar: number): Float32Array
• apply_activation(vec: Float32Array, activation: string): Float32Array

SimdMatrixOps

SIMD-accelerated matrix operations:

• matrix_vector_multiply(matrix: Float32Array, vector: Float32Array, rows: number, cols: number): Float32Array
• matrix_multiply(a: Float32Array, b: Float32Array, a_rows: number, a_cols: number, b_cols: number): Float32Array

WasmNeuralNetwork

Complete neural network implementation:

• new(layers: number[], activation: ActivationFunction)
• run(input: Float32Array): Float32Array
• randomize_weights(min: number, max: number): void
• get_weights(): Float32Array
• set_weights(weights: Float32Array): void

SimdBenchmark

Performance benchmarking utilities:

• benchmark_dot_product(size: number, iterations: number): string
• benchmark_activation(size: number, iterations: number, activation: string): string

Memory Management

The WASM module uses efficient memory management:

• Linear memory: Shared between JS and WASM for zero-copy operations
• Memory pools: Reusable memory allocation for frequent operations
• Garbage collection: Automatic cleanup of completed computations
• Memory usage: Typically < 5MB per neural network instance

Contributing

We welcome contributions to improve ruv-swarm-wasm! Areas of focus:

• SIMD optimization improvements
• Additional neural network architectures
• Performance benchmarking
• Browser compatibility testing
• Documentation and examples

Links

• Main Repository: https://github.com/ruvnet/ruv-FANN
• Documentation: https://docs.rs/ruv-swarm-wasm
• NPM Package: https://www.npmjs.com/package/ruv-swarm-wasm
• Examples: examples/
• Benchmarks: SIMD Performance Demo

License

This project is licensed under either of

• Apache License, Version 2.0, (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
• MIT License (LICENSE-MIT or http://opensource.org/licenses/MIT)

at your option.

Created by rUv - Pushing the boundaries of neural network performance in web environments.