Scan your resume against ATS criteria for this Rust Systems Engineer role at orioninnovationnaukri.
If you thrive on deterministic memory management, zero-cost abstractions, and writing safe, blazingly fast concurrent systems, this role is for you.
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.
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).
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.
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).
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).
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
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.
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).
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.
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).
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).
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
How to apply for Rust Systems Engineer at orioninnovationnaukri?
Click the "Apply on Company Website" button on this page to submit your application directly on the employer's official portal.
What is the salary for this role?
Salary details will be discussed during the interview.
What experience is required?
5+ yrs of experience is required.
Is this position still open?
Yes, currently active and accepting applications.
Explore related active roles in Banking & Finance
Rust Systems Engineer
orioninnovationnaukri · India
