Software Engineer, Robotics Platform (Rust)
Haply
Software Engineering
Canada · Montreal, QC, Canada
Posted on May 6, 2026
Required
- Fundamentals
- Strong foundation in algorithms, data structures, and core software engineering principles. Able to reason about complexity, trade-offs, and correctness, not just produce working code.
- Rust
- Strong, idiomatic Rust: ownership, lifetimes, trait design, error handling.
- Concurrency primitives and understanding of deadlock risk and lock ordering.
- Experience with cargo workspace projects: multiple crates, feature flags, build configuration.
- Comfort with unsafe Rust: raw pointers, FFI boundaries, C ABI interop.
- Systems Programming
- Shared library / DLL design (cdylib crates, symbol export, runtime loading).
- Cross-boundary serialization: understanding of protobuf or similar wire formats.
- Experience with plugin/extension architectures (runtime DLL loading, manifest-driven discovery).
- Threading models: dedicated worker threads, channel-based serialization of calls, supervision hierarchies.
- Hardware Communication
- Familiarity with low-level communication protocols (TCP/UDP sockets, serial, WebSocket, REST, SPI, I2C, etc.) in a systems-language context.
- Ability to read and debug hardware communication logs, identify protocol-level issues, and work with firmware engineers to resolve them.
- Comfort integrating with custom or proprietary hardware interfaces. Not necessarily designing the control logic, but owning the software layer that talks to it.
- Code Quality and Maintainability
- Disciplined approach to testing: unit tests, integration tests, test feature flags, mock hardware substitutes.
- Ability to identify and address technical debt without over-engineering.
- Clear API design. Keeping public surfaces minimal and stable.
- Code review skills: spotting correctness issues, concurrency hazards, and abstraction leaks.
- Frontend
- Working knowledge of TypeScript and React. Able to understand components and UI architecture patterns.
- Familiarity with WebSocket servers, HTTP servers, or protocol multiplexing in Rust (tokio / async ecosystem).
- Familiarity with Tauri (Rust + web frontend desktop app framework) for cross-stack debugging and feature work.
Ways of Working
- Self-starter who takes ownership of problems end-to-end, from investigation through to a clean, reviewed solution. Able to identify and remove blockers rather than waiting for them to be cleared.
- Plans changes before implementing. Writes up intent, considers impact on adjacent systems, and seeks review before making significant modifications.
- Communicates proactively with the team, especially when working near domain boundaries (e.g. control logic, firmware, hardware behaviour).
- Comfortable working without full domain context. Able to read code, ask the right questions, and contribute meaningfully alongside specialists.
- Proficiency with git, structured PR/review workflows, TDD, and multi-language apps.
- Experience with large, enterprise codebases and multi-repo projects.
Nice to have
- Experience with real-time or high-frequency control loops, zero-allocation hot paths.
- Exposure to robotics, haptics, teleoperation, or motion control concepts. Not required, but accelerates ramp-up.
- A genuine interest in robotics and human-machine interfaces. Curiosity about the domain goes a long way in a team moving fast at the intersection of hardware and software.
- Protobuf schema design and versioning.
- Profiling tools and performance analysis (knowledge of Tracy Profiler is a big plus).
- Advanced TypeScript / React: deep knowledge of the type system, state management patterns, performance optimization.
- Experience with TOML-based configuration schemas or manifest-driven plugin systems.
- Structured logging and observability tooling.
- OS-agnostic development (knowledge of bash and Linux as well as PowerShell and Windows).
- Experience working on DevOps in a GitLab environment.
- Bilingual French/English. Working environment is bilingual.