Benchmarks

Flow-Like's runtime is built in Rust for predictable, high-throughput workflow execution. Here are the results from our benchmark suite using mimalloc allocator.

Summary (4 Threads - Fair Comparison)

To provide a fair comparison with n8n (which uses 4 vCPUs), we benchmark with 4 worker threads:

| Metric | Value | Description | |--------|-------|-------------| | Single Execution | ~1.2ms | Time to execute a simple 2-node workflow | | Peak Throughput (4 threads) | ~124,000 workflows/sec | At 8K concurrent workflows | | Peak Throughput (16 threads) | ~244,000 workflows/sec | At 65K concurrent workflows | | Step Latency | ~20-40µs | Per-node execution overhead |

Tip

These benchmarks run on a test workflow with 2 nodes and 5 pins. Real-world performance varies based on workflow complexity and node operations.

Throughput by Concurrency Level (4 Threads)

These results use 4 worker threads to match typical cloud VM configurations (e.g., n8n's c5a.large):

| Concurrency | Throughput | Latency | |-------------|------------|---------| | 128 | ~65,000 exec/s | 2.0ms | | 512 | ~100,000 exec/s | 5.1ms | | 1,024 | ~112,000 exec/s | 9.1ms | | 2,048 | ~121,000 exec/s | 17ms | | 4,096 | ~123,000 exec/s | 33ms | | 8,192 | ~124,000 exec/s | 66ms |

Throughput by Concurrency Level (16 Threads)

With full 16-core utilization:

| Concurrency | Throughput | Latency | |-------------|------------|---------| | 128 | ~60,000 exec/s | 2.1ms | | 512 | ~140,000 exec/s | 3.6ms | | 1,024 | ~177,000 exec/s | 5.7ms | | 4,096 | ~228,000 exec/s | 18ms | | 8,192 | ~238,000 exec/s | 35ms | | 32,768 | ~241,000 exec/s | 135ms | | 65,536 | ~244,000 exec/s | 269ms |

Note

Peak throughput scales with thread count. With 4 threads: ~124K/sec. With 16 threads: ~244K/sec.

Allocator Comparison

Using mimalloc provides significant performance improvements over the system allocator:

| Allocator | Throughput (1K conc.) | Improvement | |-----------|----------------------|-------------| | mimalloc | ~222,000 exec/s | +24% | | system | ~179,000 exec/s | baseline |

Tip

Enable mimalloc with --features mimalloc for production deployments.

Running Benchmarks

Run these benchmarks on your own hardware:

Peak Throughput

# Test peak throughput with various concurrency levels
FL_CONCURRENCY_LIST="128,512,1024,4096,8192" \
RUST_LOG=off cargo bench --bench throughput_bench --features mimalloc -- peak

Allocator Comparison

# Compare system allocator vs mimalloc
RUST_LOG=off bash packages/catalog/benches/compare_allocators.sh

Single Execution

# Single workflow execution latency
RUST_LOG=off cargo bench --bench allocator_bench --features mimalloc -- single_exec

All Benchmarks

# Run all benchmarks
RUST_LOG=off cargo bench --features mimalloc

Environment Variables

Customize benchmark behavior:

| Variable | Default | Description | |----------|---------|-------------| | FL_WORKER_THREADS | CPU count | Tokio worker threads | | FL_CONCURRENCY_LIST | Auto | Comma-separated concurrency levels to test | | FL_MAX_CONCURRENCY | CPU × 8 | Max concurrency for auto-sweep | | FL_MEASURE_SECS | 10 | Measurement duration per level | | RUST_LOG | - | Set to off for accurate benchmarks |

Requirements

• Rust toolchain (stable)
• Test data in tests/ directory
• Recommended: 8+ cores for meaningful throughput tests

Note

Benchmarks use Criterion.rs for statistical analysis. Results include confidence intervals and change detection.

Benchmark Environment

Results shown were measured on:

• CPU: 16 cores (Apple M-series)
• Memory: 32GB
• OS: macOS
• Rust: Stable toolchain
• Build: Release mode with LTO
• Allocator: mimalloc

What Affects Performance?

1. Concurrency Level — Higher concurrency enables better CPU utilization up to ~65K concurrent
2. Allocator Choice — mimalloc provides ~24% improvement over system allocator
3. Node Complexity — Simple data routing is fast; heavy compute nodes dominate execution time
4. Graph Depth — More sequential nodes = more steps = longer execution
5. Data Size — Large payloads increase serialization/deserialization overhead
6. Tracing Level — Use LogLevel::Fatal for benchmarks; full tracing adds overhead

Comparison with n8n

Both benchmarks execute a comparable task: a simple 2-node workflow. For a fair comparison, we use 4 threads to match n8n's c5a.large (4 vCPU) setup (n8n benchmarks):

| Platform | Setup | Throughput | vs n8n | |----------|-------|------------|--------| | Flow-Like | 4 threads, mimalloc | ~124,000 exec/sec | 564× faster | | Flow-Like | 16 threads, mimalloc | ~244,000 exec/sec | 1,109× faster | | n8n (single) | c5a.large (4 vCPU) | ~220 exec/sec | baseline | | n8n (scaled) | 7× c5a.4xlarge | ~2,000 exec/sec | 9× baseline |

General Comparison

| Platform | Execution Model | Typical Latency | |----------|-----------------|-----------------| | Flow-Like | Native Rust, typed | ~1-2ms per workflow | | Node-based tools | JavaScript/Python | ~10-50ms per workflow | | Cloud workflows | HTTP-based | ~100-500ms per workflow |

Contributing Benchmarks

Found a performance issue or want to add a benchmark?

1. Check existing benchmarks in packages/catalog/benches/
2. Use Criterion for consistent measurement
3. Document what you're measuring and why
4. Submit a PR with before/after results