Software Developer - Rust Developer

A career in IBM Software means you’ll be part of a team that transforms our customer’s challenges into solutions.

Seeking new possibilities and always staying curious we are a team dedicated to creating the world’s leading AI-powered cloud-native software solutions for our customers. Our renowned legacy creates endless global opportunities for our IBMers so the door is always open for those who want to grow their career.

IBM’s product and technology landscape includes Research Software and Infrastructure. Entering this domain positions you at the heart of IBM where growth and innovation thrive.

We are seeking an experienced Rust Developer to join the ContextForge MCP Gateway team to lead performance-critical component rewrites.

ContextForge is a production-grade gateway proxy and registry for Model Context Protocol (MCP) servers and A2A Agents. It federates MCP and REST services providing unified discovery auth rate-limiting observability virtual servers multi-transport protocols plugins and an Admin UI: https://github.com/IBM/mcp-context-forge

We are embarking on a strategic initiative to rewrite performance-critical components in Rust to achieve 10-50x performance gains. As a Rust Developer you will rewrite multiple components such as the stdio wrapper (mcpgateway.wrapper) and protocol translator (mcpgateway.translate and mcpgateway.proxy) in Rust as well as multiple plugins and MCP Servers achieving sub-millisecond JSON-RPC parsing and 10-50x throughput improvements. You will establish Rust patterns CI/CD workflows and lay the foundation for future high-performance microservices.

Your Role And Responsibilities Performance Optimization

•             Rewrite mcpgateway.wrapper: Tokio async hyper HTTP client gRPC/tonic concurrent request multiplexing

•             Rewrite mcpgateway.translate and mcpgateway.proxy: Axum/Actix-web stdio ↔ SSE/HTTP bridging zero-copy streaming

•             Implement core performance components in Rust bindings for Python (e.g. PyO3 or similar)

•             Implement multiple MCP Servers in Rust

•             Target performance goals: Sub-millisecond JSON-RPC parsing 10-50x throughput lower memory footprint

•             Benchmark and profile: Compare Python vs Rust performance identify bottlenecks optimize hot paths

•             Optimize for desktop clients: Low memory usage fast startup time efficient resource utilization

Cross-Platform Development

•             Build cross-platform binaries: Windows macOS Linux distributions

•             Implement subprocess management: stdin/stdout handling signal handling process lifecycle

•             Handle platform-specific differences: file paths networking system calls

•             Create distribution packages: installers package managers (Homebrew apt chocolatey)

•             Ensure compatibility with existing Python gateway via gRPC/REST API boundaries

System Design & Architecture

•             Design Rust-Python interop boundaries: gRPC services REST APIs FFI if needed

•             Implement async patterns with Tokio: concurrent execution task spawning channels

•             Build HTTP clients and servers: hyper Axum/Actix-web request routing

•             Design zero-copy streaming for high throughput and low latency

•             Create clean abstractions for protocol handling and transport layers

Rust Infrastructure & Best Practices

•             Establish Rust CI/CD: Cargo workflows cross-compilation automated testing

•             Implement security practices: cargo-audit dependency scanning SBOM generation

•             Create Rust coding standards: error handling async patterns type design

•             Set up performance benchmarking: criterion.rs flamegraphs profiling

•             Write comprehensive tests: unit tests integration tests property-based testing with proptest

Collaboration & Integration

•             Work closely with Python team to define API boundaries

•             Collaborate with DevOps engineer on build and deployment pipelines

•             Partner with Engineering Manager on architecture decisions

•             Mentor team members interested in learning Rust

•             Document Rust patterns and best practices for the team

Bachelor's Degree

Master's Degree

Rust Development (3-5 years)

•             Several years of production Rust experience with at least few years in Tokio async

•             Deep understanding of Rust ownership borrowing lifetimes and type system

•             Expert-level async Rust: Tokio runtime async/await futures streams channels

•             Experience with Rust web frameworks: Axum Actix-web or similar

•             Strong knowledge of Rust HTTP clients: hyper reqwest or similar

Performance Engineering

•             Experience with performance optimization: profiling benchmarking bottleneck analysis

•             Knowledge of zero-copy techniques and efficient memory management

•             Understanding of concurrent programming and parallelism in Rust

•             Experience with performance tooling: criterion.rs flamegraph perf valgrind

•             Ability to analyze and optimize CPU memory and I/O performance

Systems Programming

•             Strong understanding of systems programming: processes threads I/O networking

•             Experience with subprocess management: stdin/stdout/stderr handling signal handling

•             Knowledge of cross-platform development challenges and solutions

•             Understanding of operating system internals: scheduling memory management I/O

•             Experience with platform-specific APIs: Windows API POSIX system calls

Protocol & Network Programming

•             Experience implementing protocols: JSON-RPC gRPC HTTP/2 WebSocket

•             Deep understanding of networking: TCP/IP HTTP TLS socket programming

•             Knowledge of serialization: serde JSON Protocol Buffers message packing

•             Experience with streaming and event-driven architectures

•             Understanding of transport protocols: SSE WebSocket gRPC streaming

Development Practices

•             Strong experience with Cargo: workspaces features dependency management

•             Knowledge of Rust testing: unit tests integration tests doc tests proptest

•             Experience with CI/CD for Rust: GitHub Actions cross-compilation release automation

•             Understanding of Rust security: cargo-audit dependency auditing secure coding

•             Proficiency with version control and code review practices

Advanced Rust Skills

•             Experience with unsafe Rust when necessary (FFI performance optimizations)

•             Knowledge of Rust macros: declarative and procedural macros

•             Understanding of Rust compiler internals and optimization flags

•             Experience with embedded Rust or no_std environments

•             Contributions to Rust open-source projects or crates

Python Interoperability

•             Experience with Rust-Python interop: PyO3 Python FFI or gRPC

•             Understanding of Python C extension API

•             Knowledge of performance differences between Python and Rust

•             Experience optimizing Python applications with Rust extensions

Distributed Systems

•             Experience with gRPC and tonic in production

•             Knowledge of service mesh architectures

•             Understanding of distributed tracing with OpenTelemetry

•             Experience with message brokers: Redis Kafka NATS

•             Knowledge of consensus algorithms and distributed coordination

Security & Performance

•             Experience with TLS/SSL in Rust: rustls native-tls

•             Knowledge of cryptographic operations in Rust

•             Understanding of side-channel attacks and constant-time operations

•             Experience with memory safety audits and fuzzing (cargo-fuzz afl.rs)

•             Knowledge of supply chain security and dependency auditing