Rust Systems Engineer

Orion Innovation Naukri; India; On-site; INR 4,000,000 - 7,000,000; Full time

Benefits offered by this job

Equity options

Flexible/remote working

Learning allowances

Job summary

Orion Innovation Naukri is seeking a Rust Systems Engineer to design high-throughput, low-latency backends. You will tackle memory management, parallel compute, and safe, fast concurrent systems in a cutting-edge environment.

The role emphasizes ownership models, custom allocators, and performance profiling using tools like Criterion and Flame Graphs. Expect work on multi-core pipelines with SIMD optimizations and real-time considerations.

Qualifications

• Advanced Rust mastery including stdsync, stdcell, unsafe Rust boundaries, and macro systems.
• Experience with thread-safe, lock-free, or fine-grained locking data structures.

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 scalable across multi-core architectures.
• 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.
• System Profiling & Benchmarking: Conduct continuous benchmarking (criterion), flame graph analysis, memory profiling (Valgrind/heap track), and CPU SIMD/vectorization optimizations.

Skills

Rust Mastery

Concurrency

Memory Management

Performance Tuning

Unsafe Rust

Tools

Criterion

tokio-console

Flame Graphs

Valgrind

mmap

Job description

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