Software Developer Rust Developer

Job description

**Introduction**

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.

**Your role and responsibilities**

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

**Required technical and professional expertise**

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

**Preferred technical and professional experience**

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

IBM is committed to creating a diverse environment and is proud to be an equal-opportunity employer.

All qualified applicants will receive consideration for employment without regard to race, color, religion, sex, gender, gender identity or expression, sexual orientation, national origin, caste, genetics, pregnancy, disability, neurodivergence, age, veteran status, or other characteristics.

IBM is also committed to compliance with all fair employment practices regarding citizenship and immigration status.

Required Skill Profession

Other General