rama 0.2

[GlenDC]

🎉 Rama 0.2 — 3+ Years in the Making

After more than three years of intense development, dozens of prototypes, countless design experiments, and production-grade battle testing, we’re incredibly proud to share Rama 0.2 with you.

Learn more at https://ramaproxy.org/ or read more below.

✨ Why Rama?

When building network proxies or similar infrastructure tools, developers are often faced with a frustrating choice:

• Use an off-the-shelf solution (like Nginx, Caddy, or Envoy), and live within its limitations — often stuck writing large configuration files or restricted in how deeply you can customize logic.
• Build your own from scratch, giving you full freedom— but at the cost of duplicating effort and constantly reinventing the same low-level wheels.

We’ve been on both sides of that equation.

Rama offers a third way.

Rama is a modular Rust framework for moving and transforming network packets — purpose-built to empower you to create highly-specialized, production-quality proxies without having to choose between reuse and control.

It’s designed for:

• Customizability: Pick and stack however you want, with custom services, layers and utilities anywhere in the mix.
• Reusability: Rama encourages composability via Tower-like Service and Layer abstractions, making it easy to share and combine logic across different applications.
• Minimalism: Built-in components are deliberately slim and focused, making them easier to fork or adapt to your own needs.
• Empowerment: Rama isn’t trying to own your whole stack — it aims to help you own it more effectively yourself.

In short: Rama gives you the batteries to get started fast, and the freedom to build exactly what you need — no more, no less.

🔋 Batteries Included

Rama ships with a robust set of built-in capabilities so you can focus on your unique business logic instead of reimplementing common functionality:

• Transports: TCP, UDP, with middleware support
• HTTP: Auto detection, HTTP/1.1, HTTP/2, dynamic/static routers, middleware, and health checks
• Web Server: Filesystem serving, redirects, routing, extractors, easily create responses and more
• HTTP Client: Easy client interface, proxy support and more
• TLS: Rustls and BoringSSL support
• DNS: Built-in DNS resolution
• Proxy Protocols: HAProxy, HTTP/S CONNECT
• Async Services: Based on traits like Service and Layer for composability with plenty of utility layers already included
• Telemetry: Built-in support for tracing, metrics, and OpenTelemetry
• User-Agent Emulation: HTTP, TLS profiles, and parsing
• Fingerprinting: JA3, JA4, JA4H
• Utilities: Error handling, connection pooling, graceful shutdown, Tower compatibility
• Binary Support: Prebuilt CLI, HTTP client

All of this is powered by a rich ecosystem of Rama crates.

For users of rama the only crate you need however is https://crates.io/crates/rama, the one to combine them all.

Explore it. Use it. Fork it. Extend it. Rama is yours to shape.

Need inspiration? Check out plenty of examples at https://github.com/plabayo/rama/tree/main/examples.

📦 Versions and Roadmap

Rama is still considered experimental software. But make no mistake — "experimental" does not mean "not production ready." Quite the opposite: Rama is already used in production by multiple companies, handling terabytes of traffic daily. It's already a solid choice for building clients, servers, and especially highly-specialized network proxies.

The 0.2 release marks a moment in time: a checkpoint where we solidify the current design and celebrate the progress we’ve made. With this milestone behind us, we’re already hard at work on version 0.3.

🔮 What’s Coming in 0.3

The 0.3 series will follow a similar release strategy as 0.2 — with frequent alpha releases that incorporate feedback early and often.

• First alpha: 0.3.0-alpha.1 — expected around May 12, 2025
• Stable release: 0.3 — planned for end of June 2025

Planned features for 0.3 including but not limited to:

• Improved BoringSSL support;
• Improved Crypto story in Rama;
• WebSocket support (protocol, client, server, proxied, tls, intercept, ...)
• Socks5 support (connect, bind, udp associate, socks5h, tls, protocol, client and server)
• Reworked internal service design with the removal of Context

For full details, check out the 0.3.0 milestone.

⚠️ Evolving with Stability in Mind

While Rama is in a strong and stable shape today, breaking changes may still occur as we evolve the framework based on feedback — from you, from partner companies, and from our own continued usage.

We release alphas every few days to a week, making it easier to:

• Spot regressions early
• Adapt to changes incrementally
• Keep feedback loops tight

Most breaking changes are mechanical rather than architectural. Rama’s core design has been stable for over a year.

🤝 Partner With Us

If you rely on Rama in production, we encourage you to:

Sponsor the project to help guide and accelerate development

Reach out to partner@ramaproxy.org for service contracts, integration help, and custom feature development. We already support several companies in this capacity — helping them migrate code, maintain integrations, and keep up with evolving versions.

Together, we're shaping the future of programmable network proxies.

Join the Journey

Rama wouldn’t exist without community input — and we’re just getting started.

We’d love your help shaping what comes next:

• Try it out and open issues for any bugs or pain points.
• Contribute features or improvements via pull requests.
• Tell us what you’re building — your feedback informs our roadmap and priorities.

We built Rama to empower developers. Now it’s your turn to show us what empowerment looks like in your hands.