Rust Systems Engineer

Orion Innovation is a premier, award-winning, global business and technology services firm. Orion delivers game-changing business transformation and product development rooted in digital strategy, experience design, and engineering, with a unique combination of agility, scale, and maturity. We work with a wide range of clients across many industries including financial services, professional services, telecommunications and media, consumer products, automotive, industrial automation, professional sports and entertainment, life sciences, ecommerce, and education.

• Job Overview: We are seeking a high-caliber Rust Systems Engineer to design, build, and optimize high-throughput, low-latency backend systems and infrastructure. In this role, you will go beyond web APIs—tackling low-level performance bottlenecks, complex state management, parallel compute algorithms, and concurrent data processing pipelines.

If you thrive on deterministic memory management, zero-cost abstractions, and writing safe, blazingly fast concurrent systems, this role is for you.

• Key Responsibilities: - High-Performance Architecture: Design and implement zero-cost, high-throughput, low-latency engine components and data processing pipelines in Rust.

• Concurrent & Thread-Safe Systems: Build thread-safe, lock-free, or fine-grained locked data structures and state machines capable of scaling across multi-core architectures without race conditions.

• Priority & Real-Time Threading: Design custom thread pools, task schedulers, and execution queues with priority-based task scheduling and resource allocation controls.

• Algorithmic Optimization: Implement complex computational logic, including high-efficiency recursive algorithms, tail-call optimizations, and dynamic cache-friendly data structures.

• Resource & Memory Management: Leverage Rust’s ownership model, lifetime annotations, custom allocators, and non-blocking I/O to achieve predictable low-latency profiling (minimizing allocations and cash misses).

• System Profiling & Benchmarking: Conduct continuous benchmarking (criterion), flame graph analysis, memory profiling (Val grind/heap track), and CPU SIMD/vectorization optimizations.

• Key Skills:
• Core Rust & Functional Programming: - Advanced Rust Mastery: Deep experience with Rust internals (stdsync, stdcell, custom Drop, unsafe Rust boundaries, and macro systems).

• Closures & Higher-Order Functions: Mastery of Rust’s functional traits (Fn, FnMut, FnOnce), capturing environments, move semantics within closures, and passing unboxed closures for zero-cost abstractions.

• Advanced Recursion & Tree Processing: Ability to structure complex recursive functions, tree/graph traversals, and dynamic programming patterns efficiently while preventing stack overflows (e.g., using explicit stack vectors or trampoline patterns).

Systems & Concurrency Engineering

• Thread Safety & Sync Primitives: In-depth understanding of memory models, cache coherence, atomic operations (AtomicBool, AtomicPtr, CAS), memory ordering (Acquire/Release/SeqCst), Send/Sync traits, and synchronization primitives (Mutex, RwLock, mpsc/crossbeam channels).

• Priority Threading & Scheduling: Practical experience implementing or customizing task schedulers, thread priority assignment, work-stealing thread pools, and priority queues (Binary Heap, custom priority locks).

• High-Performance Computing (HPC): Experience writing data-intensive, low-latency software. Knowledge of cache alignment, SIMD vectorization, memory-mapped files (mmap), and lock-free/wait-free data structures.

General Systems Knowledge

• Systems Architecture: 5+ years of software engineering experience, with 3+ years writing production-grade Rust (or a strong C/C++ background transitioning into production Rust).

• Performance Analysis: Proficiency with profiling tools (perf, Flame graphs, Criterion, Coz) and debugging async execution (tokio-console, tracing).

Nice to Have

• Experience with custom memory allocators (jemalloc, mimalloc) and bare-metal/no-std Rust environments.

• Knowledge of asynchronous runtime architectures (Tokio internals, reactor/proactor patterns, custom Future implementations).

• Familiarity with hardware-level optimizations (cache line padding, false sharing avoidance, NUMA-aware architectures).

• Experience with cross-language FFI (e.g., C/C++ interop or WebAssembly bindings).

What We Offer

• High-Impact Architecture: Work on core engine infrastructure where microsecond-level performance and stability directly drive system success.

• Modern Engineering Culture: Strong focus on code quality, explicit safety boundaries, comprehensive test suites, and strict CI/CD benchmarking.

• Competitive Package: Competitive salary, equity options, flexible/remote working arrangements, and continuous hardware/learning allowances

Orion is an equal opportunity employer, and all qualified applicants will receive consideration for employment without regard to race, color, creed, religion, sex, sexual orientation, gender identity or expression, pregnancy, age, national origin, citizenship status, disability status, genetic information, protected veteran status, or any other characteristic protected by law.

Candidate Privacy Policy

Orion Systems Integrators, LLC and its subsidiaries and its affiliates (collectively, “Orion,” “we” or “us”) are committed to protecting your privacy. This Candidate Privacy Policy (orioninc.com) (“Notice”) explains:

• What information we collect during our application and recruitment process and why we collect it;

• How we handle that information; and

• How to access and update that information.

Your use of Orion services is governed by any applicable terms in this notice and our general Privacy Policy .

- High-Performance Architecture: Design and implement zero-cost, high-throughput, low-latency engine components and data processing pipelines in Rust.

• Concurrent & Thread-Safe Systems: Build thread-safe, lock-free, or fine-grained locked data structures and state machines capable of scaling across multi-core architectures without race conditions.

• Priority & Real-Time Threading: Design custom thread pools, task schedulers, and execution queues with priority-based task scheduling and resource allocation controls.

• Algorithmic Optimization: Implement complex computational logic, including high-efficiency recursive algorithms, tail-call optimizations, and dynamic cache-friendly data structures.

• Resource & Memory Management: Leverage Rust’s ownership model, lifetime annotations, custom allocators, and non-blocking I/O to achieve predictable low-latency profiling (minimizing allocations and cash misses).

• System Profiling & Benchmarking: Conduct continuous benchmarking (criterion), flame graph analysis, memory profiling (Val grind/heap track), and CPU SIMD/vectorization optimizations.

• Core Rust & Functional Programming:

• Advanced Rust Mastery: Deep experience with Rust internals (stdsync, stdcell, custom Drop, unsafe Rust boundaries, and macro systems).

• Closures & Higher-Order Functions: Mastery of Rust’s functional traits (Fn, FnMut, FnOnce), capturing environments, move semantics within closures, and passing unboxed closures for zero-cost abstractions.

• Advanced Recursion & Tree Processing: Ability to structure complex recursive functions, tree/graph traversals, and dynamic programming patterns efficiently while preventing stack overflows (e.g., using explicit stack vectors or trampoline patterns).

Systems & Concurrency Engineering

• Thread Safety & Sync Primitives: In-depth understanding of memory models, cache coherence, atomic operations (AtomicBool, AtomicPtr, CAS), memory ordering (Acquire/Release/SeqCst), Send/Sync traits, and synchronization primitives (Mutex, RwLock, mpsc/crossbeam channels).

• Priority Threading & Scheduling: Practical experience implementing or customizing task schedulers, thread priority assignment, work-stealing thread pools, and priority queues (Binary Heap, custom priority locks).

• High-Performance Computing (HPC): Experience writing data-intensive, low-latency software. Knowledge of cache alignment, SIMD vectorization, memory-mapped files (mmap), and lock-free/wait-free data structures.

General Systems Knowledge

• Systems Architecture: 5+ years of software engineering experience, with 3+ years writing production-grade Rust (or a strong C/C++ background transitioning into production Rust).

• Performance Analysis: Proficiency with profiling tools (perf, Flame graphs, Criterion, Coz) and debugging async execution (tokio-console, tracing).

Nice to Have

• Experience with custom memory allocators (jemalloc, mimalloc) and bare-metal/no-std Rust environments.

• Knowledge of asynchronous runtime architectures (Tokio internals, reactor/proactor patterns, custom Future implementations).

• Familiarity with hardware-level optimizations (cache line padding, false sharing avoidance, NUMA-aware architectures).

• Experience with cross-language FFI (e.g., C/C++ interop or WebAssembly bindings).