At a glance
Build and optimize Modal’s Rust- and Go-based inference container runtime, accelerating startup, snapshotting, GPU workloads, and secure isolation across a large production fleet.
Summarized by AI from the original posting
What you'll do
- Build production runtime infrastructure in Rust and Go
- Improve container startup, checkpoint, and restore performance
- Build multi-GPU and accelerator-aware snapshotting
- Design zero-copy and low-copy data paths
- Optimize snapshot pipelines
- Improve container image and filesystem performance
- Extend sandboxed runtime for new GPUs, drivers, profiling tools, and device capabilities
- Debug failures involving system calls, virtual memory, process lifecycle, kernel behavior, GPU drivers, and container isolation
- Roll out runtime and kernel changes across a heterogeneous fleet
- Work across runtime, scheduler, storage, and GPU infrastructure
Requirements
- 01Strong Linux systems knowledge
- 02Experience building or debugging container runtimes, sandboxes, Linux kernel, or similarly low-level infrastructure
- 03Strong programming ability in Rust, Go, or another systems language
- 04Experience profiling and improving systems dominated by memory movement, I/O, synchronization, or kernel interactions
- 05Ability to debug across application, runtime, driver, and kernel abstraction boundaries
- 06Ability to turn loosely defined production problems into reliable systems
- 07Ownership mindset and ability to work with internal teams and customers
Perks
Skills
Full description
About the role
Modal’s Inference Runtime team owns the container runtime stack used to run inference and training workloads across our fleet. We work at the boundary of Linux, containers, filesystems, storage, GPU drivers, and distributed systems.Our goal is to make demanding ML workloads start quickly, run efficiently, and remain securely isolated — whether they use a single GPU, hundreds of gigabytes of memory, or multiple GPUs connected with RDMA.We’re looking for a systems engineer who enjoys working deep in the stack. You’ll build production runtime infrastructure in Rust and Go, diagnose difficult Linux and performance problems, and help determine the architecture of Modal’s container platform. You’ll also work closely with maintainers of gVisor and contribute to the runtime itself when the right fix belongs upstream.
What you’ll work on
Make container startup, checkpoint, and restore dramatically faster for large inference and training workloads.
Build multi-GPU and accelerator-aware snapshotting, including efficient handling of GPU memory and RDMA-enabled workloads.
Design zero-copy and low-copy data paths between container memory, filesystems, storage, and Modal’s runtime.
Optimize large snapshot pipelines using techniques such as parallel uploads, direct I/O, incremental snapshots, and more efficient memory handling.
Improve container image and filesystem performance across EROFS, FUSE, page caches, overlay filesystems, and remote storage.
Extend our sandboxed runtime to support new GPUs, drivers, profiling tools, and device capabilities across NVIDIA and AMD hardware.
Debug complex failures involving system calls, virtual memory, process lifecycle, kernel behavior, GPU drivers, and container isolation.
Safely roll out runtime and kernel changes across a heterogeneous fleet using compatibility controls, scheduling constraints, feature flags, and observability.
Work across the runtime, scheduler, storage, and GPU infrastructure—and take ambiguous production problems from investigation through deployment.
What we’re looking for
Strong Linux systems knowledge, particularly processes, virtual memory, filesystems, system calls, scheduling, namespaces, cgroups, and signals.
Experience building or debugging container runtimes, sandboxes, Linux kernel, or similarly low-level infrastructure.
Strong programming ability in Rust, Go, or another systems language, with an interest in becoming productive in both Rust and Go.
Experience profiling and improving systems where memory movement, I/O, synchronization, or kernel interactions dominate performance.
Comfort debugging across abstraction boundaries, from application behavior down through runtimes, drivers, and the kernel.
An ability to turn loosely defined production problems into well-designed, reliable systems.
A desire to own important infrastructure and work closely with both internal teams and customers.
Particularly relevant experience
Any of the following would be helpful, but none is required:
gVisor,
runsc,runc, OCI runtimes, seccomp, or checkpoint/restore systems.Linux kernel development, virtualization, sandboxing, kernel modules, or device proxying.
CUDA, ROCm, GPU drivers, accelerator virtualization, or GPU profiling.
RDMA and high-performance networking.
FUSE, EROFS, direct I/O,
mmap, page-cache behavior, or storage engines.Large-memory or multi-GPU inference and training systems.
Contributions to open-source systems software.
Prior gVisor or machine-learning experience is not required. We care more about strong systems fundamentals, curiosity, and the ability to learn unfamiliar parts of the stack.
Why this role
The container runtime is directly on the critical path for inference performance. Improvements here can substantially reduce cold starts, increase token throughput, unlock new accelerator types, and make previously impractical workloads possible.This is an opportunity to work on unusually deep systems problems with immediate production impact. You’ll have room to shape the architecture, contribute to open-source runtime technology, and take ownership of foundational infrastructure used by every inference and training workload on Modal.
Compensation: $220K - $300K