Rust Systems and Research
Workflow Engines, Lattices, and WebAssembly
By Oleksii Vasylenko, Technical Lead · Updated
Rust is an emerging specialty in my work, not my primary professional identity. I am a Technical Lead with deep Node.js and TypeScript experience; I use Rust where its ownership model, predictable memory behavior, native performance, or systems ecosystem changes what can be built. Current examples include the Orch8 workflow engine, lattice cryptanalysis tooling, numerical algorithms, WebAssembly modules, and GPU-assisted research code.
What This Means for Your Business
Rust prevents data races and memory-safety errors through compile-time ownership and borrowing rules. That matters in long-running engines, native numerical kernels, cryptographic tooling, and code crossing WebAssembly or GPU boundaries. It does not make business logic correct, remove the need for recovery tests, or automatically make a system fast.
The tradeoff is real: Rust asks for more design work around ownership, lifetimes, error types, and concurrency. I do not recommend it for every API or product feature. Node.js and TypeScript remain faster choices for many networked applications. Rust earns its place when profiling, safety constraints, portability, or control over memory and execution makes that extra engineering cost worthwhile.
How I Have Used This in Production
Durable Workflow Engine
Solo-built a complete orchestration engine in Rust — 10 workspace crates covering the execution engine, storage layer, REST API (Axum), gRPC interface (Tonic), CLI, type system, event publisher, push notifications, and mobile API layer. Every crate, every API, every integration written by one person. Tokio async runtime for structured concurrency, SQLx for type-checked database queries, Wasmtime for sandboxed plugin execution. Snapshot-based state persistence eliminates the history replay overhead that makes Temporal operationally expensive.
Lattice Cryptanalysis Library (g6k-rs)
Solo-built a complete lattice sieving and reduction library in Rust — 16K lines implementing LLL, BKZ, BDGL/BGJ1/HK3 sieves, CVP solvers, Coppersmith small-root finding, and LWE attacks. SIMD-accelerated inner products, FHT-LSH bucketing, Metal GPU sieving, and GMP-backed arbitrary-precision lattices for cryptanalytic applications.
Browser-Side Cryptographic Operations
Built Rust-to-WebAssembly pipelines for client-side blockchain interactions and ZK proof generation. Cryptographic operations that would take seconds in JavaScript execute in milliseconds in WASM-compiled Rust — with memory safety guarantees that are non-negotiable when handling private keys and proof witnesses.
Technologies
Related Expertise
The durable workflow engine is the largest Rust system I have built. See the architecture decisions behind snapshot-based execution and why history replay is a broken model.
Durable Workflow Engine Architecture — Beyond Temporal — Snapshot-Based ExecutionLattice research is where most of my low-level Rust optimization work happens: SIMD, memory layout, numerical stability, and GPU kernels.
Lattice Cryptanalysis and Reduction — Breaking Cryptographic Assumptions with Lattice AlgorithmsRust compiled to WebAssembly brings systems-level performance and safety to the browser. See how I built cryptographic pipelines for blockchain clients.
Rust and WebAssembly — Native Performance in the BrowserFrequently Asked Questions
What makes Rust suitable for mission-critical systems?
Rust prevents data races, use-after-free bugs, buffer overflows in safe code, and null pointer dereferences through its type and ownership systems. Those guarantees are useful for long-running engines and native tooling, but they do not prevent incorrect business rules, bad recovery logic, or flawed cryptography. Testing and system design still decide whether the product is dependable.
When should a team choose Rust over a garbage-collected language like TypeScript or Go?
Choose Rust when measurement or constraints point to native performance, predictable memory, safe concurrency, small portable binaries, WebAssembly, or direct systems integration. Choose TypeScript or Go when delivery speed, hiring, framework maturity, and ordinary network performance matter more. Rust should solve a named constraint, not serve as an architectural fashion statement.
What production experience does Oleksii Vasylenko have with Rust?
Oleksii Vasylenko has solo-built complete production-grade Rust systems, including a durable workflow orchestration engine spanning 10 workspace crates — execution engine, storage, Axum REST API, Tonic gRPC, CLI, and more — using Tokio, SQLx, and Wasmtime. He also built g6k-rs, a 16K-line lattice cryptanalysis library with SIMD acceleration and Metal GPU sieving, and Rust-to-WebAssembly pipelines for client-side ZK proof generation at Panther Protocol.
What goes wrong when teams build mission-critical systems in the wrong language?
The wrong language is the one that makes the team's real constraint harder to manage. Rust can add unnecessary development cost to ordinary product APIs. A garbage-collected runtime can be a poor fit for a tightly controlled native kernel. Teams should profile the workload, define failure and latency requirements, and keep the specialized implementation behind a narrow interface.
How can a company engage Oleksii Vasylenko for Rust architecture work?
Oleksii works on bounded Rust systems such as workflow engines, numerical and cryptographic tooling, WebAssembly modules, and performance-sensitive libraries. He can also assess whether an existing Node.js or TypeScript system needs a Rust component at all. Teams can contact him through ovasylenko.com before committing the whole product to a systems stack.
Further Reading
Does part of your system genuinely need Rust?
I can help identify whether Rust belongs in the architecture, isolate the boundary, and build the performance-sensitive or safety-sensitive component without forcing the entire product onto a systems stack.
Discuss your Rust boundaryEngagement options and availability →