SDE III Backend Engineer — Simulation / DES

GreyOrange; Bengaluru; In loco; INR 2.500.000 - 4.200.000; Tempo pieno

Descrizione del lavoro

GreyOrange in Bengaluru, India, seeks a backend engineer to own and extend the core simulation engine, focusing on tick loop, task allocation, and multi-agent path planning.

You will write Rust in an async Tokio runtime, optimize latency budgets, and integrate third-party algorithm plugins while maintaining high performance at scale.

Candidates should have 5–8 years in backend or systems roles, strong Rust experience, and familiarity with graph algorithms and real-time simulation.

Competenze

• 5-8 years backend or systems engineering experience.
• Production Rust experience (2+ years preferred).
• Experience with async Rust and low-latency systems.

Mansioni

• Own core simulation engine components (tick loop, task allocation, traffic resolution).
• Develop and optimize simulation algorithms for 400+ agent scale.
• Integrate third-party algorithm plugins within per-tick latency budget.

Conoscenze

Rust experience

Async Rust (Tokio)

Discrete-event simulation

Multi-agent systems

Graph algorithms

Performance optimization

Strumenti

Tokio

Wasmtime/Wasmer/Extism

Descrizione del lavoro

Own core simulation engine work: the tick loop, task allocation, traffic and collision resolution, and the boundary where third-party algorithm plugins hook into the simulation.

What You'll Do

• Build and extend the discrete-event simulation core: tick scheduling, robot state machines, task generation, and traffic or path deconfliction.
• Implement and optimize simulation algorithms — task allocation heuristics, multi-agent path planning such as SIPP-A* — for correctness and performance at 400+ agent scale.
• Own parts of the plugin boundary: calling into sandboxed third-party algorithm modules from the simulation tick loop within a strict per-tick latency budget.
• Work on the in-memory map and graph representation the simulator uses for pathfinding and spatial queries.
• Write high-quality, tested Rust in an async runtime (Tokio), with close attention to allocation patterns and tick-time predictability.

What We're Looking For

• 5-8 years of backend or systems engineering experience, with meaningful production Rust experience (2+ years preferred).
• Experience with async Rust (Tokio or equivalent) and building systems with strict per-operation latency budgets.
• Solid grounding in discrete-event simulation concepts, multi-agent systems, or game/robotics simulation — tick loops, state machines, deterministic replay.
• Comfort with algorithmic work: graph algorithms, pathfinding (A*, Dijkstra, or similar), or scheduling and allocation problems.

Nice to Have

• Experience with WebAssembly runtimes (Wasmtime, Wasmer, Extism) or sandboxing untrusted code.
• Familiarity with warehouse automation, robotics, AGV/AMR fleet management, or traffic simulation.
• Direct experience with SIPP, A*, or other real-time multi-agent path planning algorithms.