Featured

Rust Systems Engineer

Orion Innovation·Senior·On-site · India

Posted Aug 8, 2026·orioninnovation.com

Company Overview

Orion Innovation is a global business and technology services firm delivering business transformation and product development rooted in digital strategy, experience design, and engineering across industries including financial services, professional services, telecommunications, media, consumer products, automotive, industrial automation, sports, entertainment, life sciences, ecommerce, and education.

Position Overview

The Rust Systems Engineer designs, builds, and optimizes high-throughput, low-latency backend systems and infrastructure. The role focuses on low-level performance bottlenecks, complex state management, parallel compute algorithms, and concurrent data processing pipelines using deterministic memory management and zero-cost abstractions.

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 cache misses).
System Profiling & Benchmarking: Conduct continuous benchmarking (Criterion), flame graph analysis, memory profiling (Valgrind/heaptrack), and CPU SIMD/vectorization optimizations.

Key Skills & Requirements

Core Rust & Functional Programming

Advanced Rust Mastery: Experience with Rust internals (std::sync, std::cell, custom Drop, unsafe Rust boundaries, and macro systems).
Closures & Higher-Order Functions: Knowledge 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: 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: Experience implementing or customizing task schedulers, thread priority assignment, work-stealing thread pools, and priority queues (BinaryHeap, 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 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 they 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

Company Overview

Position Overview

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 cache misses).
System Profiling & Benchmarking: Conduct continuous benchmarking (Criterion), flame graph analysis, memory profiling (Valgrind/heaptrack), and CPU SIMD/vectorization optimizations.

Key Skills & Requirements

Core Rust & Functional Programming

Advanced Rust Mastery: Experience with Rust internals (std::sync, std::cell, custom Drop, unsafe Rust boundaries, and macro systems).
Closures & Higher-Order Functions: Knowledge 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: 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: Experience implementing or customizing task schedulers, thread priority assignment, work-stealing thread pools, and priority queues (BinaryHeap, 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 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 they 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

Apply

Back to jobs

Featured

Rust Systems Engineer

Orion Innovation·Senior·On-site · India

Posted Aug 8, 2026·orioninnovation.com

Company Overview

Position Overview

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 cache misses).
System Profiling & Benchmarking: Conduct continuous benchmarking (Criterion), flame graph analysis, memory profiling (Valgrind/heaptrack), and CPU SIMD/vectorization optimizations.

Key Skills & Requirements

Core Rust & Functional Programming

Advanced Rust Mastery: Experience with Rust internals (std::sync, std::cell, custom Drop, unsafe Rust boundaries, and macro systems).
Closures & Higher-Order Functions: Knowledge 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: 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: Experience implementing or customizing task schedulers, thread priority assignment, work-stealing thread pools, and priority queues (BinaryHeap, 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 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 they 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

Company Overview

Position Overview

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 cache misses).
System Profiling & Benchmarking: Conduct continuous benchmarking (Criterion), flame graph analysis, memory profiling (Valgrind/heaptrack), and CPU SIMD/vectorization optimizations.

Key Skills & Requirements

Core Rust & Functional Programming

Advanced Rust Mastery: Experience with Rust internals (std::sync, std::cell, custom Drop, unsafe Rust boundaries, and macro systems).
Closures & Higher-Order Functions: Knowledge 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: 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: Experience implementing or customizing task schedulers, thread priority assignment, work-stealing thread pools, and priority queues (BinaryHeap, 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 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 they 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

Apply

Back to jobs

Featured

Rust Systems Engineer

Orion Innovation·Senior·On-site · India

Posted Aug 8, 2026·orioninnovation.com

Company Overview

Position Overview

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 cache misses).
System Profiling & Benchmarking: Conduct continuous benchmarking (Criterion), flame graph analysis, memory profiling (Valgrind/heaptrack), and CPU SIMD/vectorization optimizations.

Key Skills & Requirements

Core Rust & Functional Programming

Advanced Rust Mastery: Experience with Rust internals (std::sync, std::cell, custom Drop, unsafe Rust boundaries, and macro systems).
Closures & Higher-Order Functions: Knowledge 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: 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: Experience implementing or customizing task schedulers, thread priority assignment, work-stealing thread pools, and priority queues (BinaryHeap, 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 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 they 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

Company Overview

Position Overview

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 cache misses).
System Profiling & Benchmarking: Conduct continuous benchmarking (Criterion), flame graph analysis, memory profiling (Valgrind/heaptrack), and CPU SIMD/vectorization optimizations.

Key Skills & Requirements

Core Rust & Functional Programming

Advanced Rust Mastery: Experience with Rust internals (std::sync, std::cell, custom Drop, unsafe Rust boundaries, and macro systems).
Closures & Higher-Order Functions: Knowledge 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: 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: Experience implementing or customizing task schedulers, thread priority assignment, work-stealing thread pools, and priority queues (BinaryHeap, 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 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 they 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

Apply

Back to jobs

Featured

Rust Systems Engineer

Orion Innovation·Senior·On-site · India

Posted Aug 8, 2026·orioninnovation.com

Company Overview

Position Overview

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 cache misses).
System Profiling & Benchmarking: Conduct continuous benchmarking (Criterion), flame graph analysis, memory profiling (Valgrind/heaptrack), and CPU SIMD/vectorization optimizations.

Key Skills & Requirements

Core Rust & Functional Programming

Advanced Rust Mastery: Experience with Rust internals (std::sync, std::cell, custom Drop, unsafe Rust boundaries, and macro systems).
Closures & Higher-Order Functions: Knowledge 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: 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: Experience implementing or customizing task schedulers, thread priority assignment, work-stealing thread pools, and priority queues (BinaryHeap, 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 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 they 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

Company Overview

Position Overview

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 cache misses).
System Profiling & Benchmarking: Conduct continuous benchmarking (Criterion), flame graph analysis, memory profiling (Valgrind/heaptrack), and CPU SIMD/vectorization optimizations.

Key Skills & Requirements

Core Rust & Functional Programming

Advanced Rust Mastery: Experience with Rust internals (std::sync, std::cell, custom Drop, unsafe Rust boundaries, and macro systems).
Closures & Higher-Order Functions: Knowledge 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: 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: Experience implementing or customizing task schedulers, thread priority assignment, work-stealing thread pools, and priority queues (BinaryHeap, 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 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 they 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

Apply

Internship: Embedded Software Engineer

Internship: Forward Deployed Engineer, Test

Software Integration Engineer

Developer, Full Stack/iOS

Senior Rust Engineer

Senior Systems Engineer

Senior Software Engineer - Rust

Rust Developer

Rust Engineer - Networking Centric

Backend Developer

Backend Software Engineer

Software Engineer

Rust Developer Ai Training

Senior Foundation Engineer

Senior Backend Engineer - Platform

Company Overview

Position Overview

Key Responsibilities

Key Skills & Requirements

Core Rust & Functional Programming

Systems & Concurrency Engineering

General Systems Knowledge

Nice-To-Have

What they Offer

Company Overview

Position Overview

Key Responsibilities

Key Skills & Requirements

Core Rust & Functional Programming

Systems & Concurrency Engineering

General Systems Knowledge

Nice-To-Have

What they Offer

Company Overview

Position Overview

Key Responsibilities

Key Skills & Requirements

Core Rust & Functional Programming

Systems & Concurrency Engineering

General Systems Knowledge

Nice-To-Have

What they Offer

Company Overview

Position Overview

Key Responsibilities

Key Skills & Requirements

Core Rust & Functional Programming

Systems & Concurrency Engineering

General Systems Knowledge

Nice-To-Have

What they Offer

Company Overview

Position Overview

Key Responsibilities

Key Skills & Requirements

Core Rust & Functional Programming

Systems & Concurrency Engineering

General Systems Knowledge

Nice-To-Have

What they Offer

Company Overview

Position Overview

Key Responsibilities

Key Skills & Requirements

Core Rust & Functional Programming

Systems & Concurrency Engineering

General Systems Knowledge

Nice-To-Have

What they Offer

Company Overview

Position Overview

Key Responsibilities

Key Skills & Requirements

Core Rust & Functional Programming

Systems & Concurrency Engineering

General Systems Knowledge

Nice-To-Have

What they Offer

Company Overview

Position Overview