Principal Rust Engineer Language Runtime

In this role, you will: 

Runtime & VM

• Implement and optimize an async register-based virtual machine with cooperative scheduling and built-in function dispatch.
• Translate language semantics from a reference C implementation into idiomatic, correct Rust.

Compiler

• Extend a multi-stage compiler pipeline (lexer, parser, AST, IR, codegen).
• Deliver new language features end-to-end with conformance and property-based tests.

Protocol & Data Layer

• Extend a binary wire protocol implementation reverse-engineered from C source.
• Own TLS, authentication, and connection pooling.

Async & Networking

• Maintain a Tokio-based async runtime handling thousands of concurrent requests with shared state and admission control.
• Contribute to HTTP, WebSocket, and gRPC server layers.

Engineering & Build

• Manage a large multi-crate Cargo workspace — dependency hygiene, CI performance, and release engineering.

Team Enablement

• Mentor senior engineers (20+ years platform experience) adopting Rust — teaching-oriented code reviews, pair programming, and progressive ownership handoff.
• Document architecture decisions and maintain design docs as first-class deliverables.

Your background: 

• Overall 10+ years of Software Engineering Experience
• 5+ years production Rust in systems software (runtimes, compilers, databases, or networking).
• Compiler or language runtime experience — at least one of: parser, AST/IR, bytecode compiler, VM, or interpreter.
• Async Rust at scale — Tokio, shared-state concurrency, cancellation safety.
• Large multi-crate workspace fluency.
• Ability to read large C codebases and derive correct Rust implementations.
• Mentorship mindset — patience, clear communication, progressive handoff.
• Long-term ownership orientation — multi-year commitment.
• Excellent written and verbal English.
• CS degree or equivalent (data structures, algorithms, OS, compilers)

Additionally, it would be beneficial if you have:

• VM design — opcode dispatch, cooperative scheduling, register allocation.
• Binary protocol reverse-engineering and zero-copy parsing.
• Property-based testing (proptest, quickcheck).
• Concurrent data structures — DashMap, Moka, lock-free patterns.
• Axum / Tower / WebSocket server experience.
• Developer tooling protocols (LSP, DAP).
• Observability — tracing, OpenTelemetry, Prometheus.
• Database connectivity — pooling, transactions, schema resolution.
• Experience onboarding engineering teams into Rust.
• AI-assisted development tools (Copilot, Claude).