The core engine is written in Rust — memory-safe with no GC pauses, delivering low latency and high throughput together.
0
requests / sec (benchmark)
Response time comparison
BotShade (Rust)
12ms
Go
28ms
Node.js
65ms
Python
120ms
Ruby
180ms
Rust's ownership model guarantees memory safety without a GC. Even at 10,000 concurrent connections we run on 1/10th the memory of Node.js, dramatically cutting infrastructure cost.
No latency spikes from GC pauses
Tiny 8MB idle footprint
Linear scaling with connection count
No memory leaks under long-running operation
Memory usage comparison
BotShade (Rust)
8MB
45MB
120MB
Go
12MB
80MB
350MB
Node.js
35MB
180MB
1.2GB
Python
28MB
220MB
2.1GB
cargo bench
test
bench_message_parse ... bench:
142 ns/iter (+/- 8)
test
bench_command_dispatch ... bench:
891 ns/iter (+/- 23)
test
bench_event_broadcast ... bench:
2,341 ns/iter (+/- 105)
test
bench_state_serialize ... bench:
456 ns/iter (+/- 12)
test
bench_db_query_cached ... bench:
1,203 ns/iter (+/- 45)
result
5 benchmarks passed, 0 failed; 0 measured
Each core operation completes in nanoseconds — message parsing, command dispatch, event broadcast — all of it under a microsecond.
Message parse: 142ns
Command dispatch: 891ns
Event broadcast: 2.3μs
State serialization: 456ns
A core engine that runs more than 10,000 concurrent bots needs both safety and performance — there is no acceptable trade-off.
Zero garbage-collection pause time
Memory safety guaranteed at compile time
Execution speed on par with C/C++
Thread-safe concurrency verified by the compiler
0
GC pause time
10K+
Concurrent bots
12ms
Average latency
3x
Memory efficiency (vs Node.js)
Memory-safe
Rust's ownership model guarantees memory safety without a GC, eliminating leaks at the source and keeping performance steady over the long haul.
Zero-cost abstractions
High-level abstractions with no runtime cost — productivity and performance, both.
Concurrency
A tokio-based async runtime efficiently handles 10,000+ concurrent connections.
Compile-time guarantees & type safety
Catches whole classes of bugs before they ship, dramatically reducing runtime errors and minimizing production incidents.