Using Rust in non-Rust servers to improve performance

Original Article ↗ Hacker News Discussion ↗

Integration of Rust into Non-Rust Stacks

  • Multiple approaches discussed: native FFI (e.g., Node N-API, PHP extensions, Elixir NIFs), subprocess/CLI “caveman” model, and WebAssembly.
  • Subprocess model surprises many by being quite competitive in performance while offering isolation and simpler failure modes; can be improved via worker pools.
  • Native bindings can be very concise in Rust but get complex once you touch deeper runtime semantics (Node, BEAM).
  • For BEAM, some warn that unsafe NIFs can crash the VM; Rust wrappers claim to prevent this via panic-catching and “dirty schedulers,” though details are not fully clear.
  • JVM integration via tools like Chicory is noted; Java 11+ compatibility mentioned.

Performance, Memory, and What’s Really Being Measured

  • Large memory reduction (e.g., ~13 MB vs ~1300 MB) is praised, especially for self-hosting and cheap VPSes.
  • Others note Node was run in cluster mode, inflating memory to use all cores; for small machines you wouldn’t need that many workers.
  • Several argue the main win is “not JavaScript,” and that C, C++, Go, C#, Java, Zig, etc. could give similar or partial gains.
  • Detailed discussion that apparent memory usage is heavily affected by allocators (glibc vs jemalloc), GC strategies, and OS behavior (mmap, madvise), so naive RSS comparisons can mislead.
  • Some point out GC-based runtimes intentionally hoard memory to reduce pause frequency; savings must be weighed against tiny cloud cost differences and engineering time.

Rust as a Web Backend Language

  • Enthusiasts claim Rust web dev (Actix, Axum, Tide etc.) feels similar to Go/Flask once you “think in Rust,” with excellent throughput and low footprint.
  • Others report a significant initial productivity hit, especially around borrow checking, async, and redesigning “obvious” solutions.
  • Counterpoint: for typical CRUD APIs, lifetimes and borrow checker mostly “disappear”; request-scoped data maps well to Rust’s model.
  • Some argue Rust’s type system, enums/sum types, pattern matching, and Result/Option ergonomics materially reduce logic bugs vs Go/JS.

Concurrency and Safety

  • Rust’s data-race freedom in-process is contrasted with Go/C++; proponents see this as a major advantage.
  • Critics note this doesn’t help with distributed-system races or cross-process/shared-memory issues, so “fearless concurrency” is narrower than marketing suggests.

Optimization vs Development Speed

  • Ongoing debate: some say most apps will never hit scale where Rust’s efficiency pays off; hardware is cheaper than slow dev.
  • Others advocate “reasonable efficiency by default,” especially for widely deployed software and environmental impact, but agree not every project should be maximally tuned.