Rust Engineer

Bot Jobs; Myrtle Point (OR); Remote; USD 86,000 - 138,000; Full time

Benefits offered by this job

Technical ownership

R&D freedom

Competitive compensation

Compute infrastructure

Flexible remote

Job summary

Deepslate is seeking a Rust Engineer to join a fully remote team working on real-time inference engines and the Rust-based model stack. You will own critical components, design architecture, and contribute to production-ready systems.

The role emphasizes writing high-quality Rust code, building scalable architectures, and optimizing performance for low-latency real-time responses in conversational models.

Qualifications

• Strong hands-on experience with Rust, including ownership, borrowing, composition, and idiomatic Rust design patterns.
• Solid experience with async Rust and structuring concurrent applications.
• Experience building and working with microservice architectures.
• A true startup mindset: comfortable navigating early-stage codebases and limited docs.
• Drive and vision: actively shape the product, architect solutions, and own projects.

Responsibilities

• Build the inference engine and core components of the model stack in Rust from architecture to production.
• Design the architecture for component communication and extensibility.
• Develop real-time async Rust systems with low latency for streaming audio.
• Identify bottlenecks and optimize latency, throughput, and resource usage.
• Write production-ready code and improve tooling and documentation.

Skills

Rust

async Rust

microservice architectures

startup mindset

ownership & architecture

Tools

bindgen

Job description

Rust Engineer

Location

Remote or Berlin (Office available)

Location

Germany

Employment Type

Full time

Location Type

Remote

Department

Engineering

Compensation

• €75K – €120K Offers Equity

Your Role

Many core parts of our model stack are written in Rust. At the heart of it is our inference engine, written entirely in Rust.

Your mission is to build and improve these systems. You will work on the inference engine, take ownership of other Rust projects, and help decide how everything fits together. We need someone who enjoys writing good Rust code and can design software that stays understandable and maintainable as it grows.

Our models need to respond in real time. The software you build will directly influence how fast and reliable they are in an actual conversation.

What You'll Do

• Build in Rust: Develop our inference engine and other core components of the model stack. Take projects from the first architectural decisions to running in production.
• Design the Architecture: Decide how components and services communicate, where responsibilities belong, and how we can extend the system without making it harder to work on.
• Work on Real-Time Systems: Build async Rust systems that handle concurrent workloads and streaming audio with low latency.
• Improve Performance: Find bottlenecks, understand what's causing them, and improve latency, throughput, and resource usage.
• Write Production-Ready Code: Build software that we can test, debug, and operate reliably. Help improve our tooling, documentation, and development practices along the way.

What We're Looking For: Must-Haves

• Strong hands-on experience with Rust, including ownership, borrowing, composition, and idiomatic Rust design patterns.
• Solid experience with async Rust. You know how to structure concurrent applications and deal with synchronization, cancellation, and backpressure.
• Experience building and working with microservice architectures.
• A true startup mindset: You are comfortable navigating the glorious chaos of an early-stage codebase. Inconsistent structures, missing docs. You name it, you'll help fix it.
• Drive and Vision: You aren't just looking to blindly process Jira tickets. You want to actively shape the product, architect solutions, and take complete project ownership.

Ideally, You Also Bring

• Knowledge of actor systems and experience using actors to structure concurrent applications.
• Experience with real-time systems, whether in embedded environments or the cloud. Both are relevant to us.
• Experience with C/C++ interoperability, including generating Rust bindings with bindgen.

Nice-to-Haves

• Experience with CUDA or GPU computing.
• Contributions to open-source projects.
• Python knowledge.
• Experience with lower-level performance engineering, such as debugging memory leaks or understanding performance at the machine instruction level.
• German, spoken and written.

What We Offer

• Technical Ownership: Our Rust stack is central to the company. You'll have the trust and freedom to make architectural decisions and see them through.
• True R&D Freedom: We give you the time, resources, and trust to research and build technology that simply doesn't exist yet. There are difficult problems here, and room to try different approaches.
• Competitive Compensation: We are well-funded by top-tier VCs. We offer a highly competitive salary. We are looking for top talent, and we are ready to pay for it.
• Serious Compute: You will have access to the hardware and cloud infrastructure necessary to build, test, and optimize the systems running our models.
• Absolute Flexibility: Fully remote work, asynchronous communication, and zero micromanagement. We care about your output and impact, not your schedule.