urlx

A memory-safe Rust reimplementation of curl and libcurl.

urlx is a from-scratch rewrite of curl in Rust. Zero unsafe outside the FFI boundary. Built on tokio and rustls — no OpenSSL. Behavioral compatibility with curl is the goal.

Highlights

• Memory-safe — zero unsafe in the core library and CLI; all unsafe confined to the FFI crate with safety documentation
• No OpenSSL — TLS 1.2/1.3 via rustls, with cert pinning, custom CAs, and client certificates
• Drop-in CLI — urlx aims to accept the same flags and produce the same output as curl
• Drop-in C library — liburlx-ffi exposes the libcurl C ABI so existing C/C++ programs can link against it
• Idiomatic Rust API — liburlx provides a clean async/sync API modeled on curl's Easy/Multi handles
• Broad protocol support — HTTP/1.1, HTTP/2, HTTP/3 (QUIC), FTP/FTPS, SFTP/SCP, WebSocket, SMTP, IMAP, POP3, MQTT
• 2,200+ tests — unit, integration (against real servers), property-based, and fuzz harnesses
• Async core — tokio runtime with a blocking Easy wrapper and native async Multi API

Quick Start

CLI

urlx https://example.com                                    # GET a URL
urlx -d '{"key":"val"}' -H 'Content-Type: application/json' # POST JSON
urlx -Lo archive.tar.gz https://example.com/archive.tar.gz  # Download file
urlx -u user:pass https://api.example.com/admin              # Basic auth
urlx -F "file=@photo.jpg" https://example.com/upload         # Multipart upload
urlx -Z https://a.com https://b.com https://c.com            # Parallel transfers

Rust Library

let mut easy = liburlx::Easy::new();
easy.url("https://httpbin.org/get")?;
let response = easy.perform()?;

println!("{}", response.status());       // 200
println!("{}", response.body_str()?);    // {"origin": "..."}

[dependencies]
liburlx = "0.1"

C Library (libcurl-compatible)

#include "urlx.h"

CURL *curl = curl_easy_init();
curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
CURLcode res = curl_easy_perform(curl);
curl_easy_cleanup(curl);

Installation

cargo install --path crates/urlx-cli   # from source

cargo build --workspace --release      # build everything
cargo test --workspace                 # run the test suite

Components

Protocol & Feature Parity

Architecture

                    ┌─────────────┐
                    │   urlx CLI  │  Drop-in curl replacement
                    └──────┬──────┘
                           │
┌──────────────┐    ┌──────┴──────┐
│ liburlx-ffi  │────│   liburlx   │  Core Rust library
│  (C ABI)     │    │  (Rust API) │
└──────────────┘    └──────┬──────┘
                           │
              ┌────────────┼────────────┐
              │            │            │
        ┌─────┴─────┐ ┌───┴───┐ ┌─────┴─────┐
        │ Protocols  │ │  TLS  │ │    DNS    │
        │ HTTP, FTP, │ │rustls │ │  Cache,   │
        │ WS, SMTP...│ │       │ │  HE, DoH  │
        └────────────┘ └───────┘ └───────────┘

• Zero unsafe outside FFI — liburlx and urlx-cli are 100% safe Rust
• Async core — tokio runtime with blocking Easy wrapper and native async Multi API
• No OpenSSL — TLS entirely via rustls
• Strict linting — clippy::all denied, unwrap_used denied in library code, no panics

Feature Flags

Default features: http, http2, rustls, decompression.

Contributing

urlx follows strict test-driven development — every feature starts with a failing test. The full guardrail suite (fmt, clippy, test, deny, doc) runs on every commit via pre-commit hooks and CI.

cargo fmt && cargo clippy --all-targets && cargo test --workspace

Acknowledgements

urlx would not exist without curl by Daniel Stenberg. curl's behavior is our specification, and its decades of real-world testing inform every design decision.

Built with tokio, rustls, h2, quinn, and hyper (test infrastructure).

License

MIT

lib.rs:

liburlx — A memory-safe URL transfer library.

This is an idiomatic Rust reimplementation of libcurl, providing both blocking (Easy) and async (Multi) APIs for URL transfers.

Quick Start

The library is currently in early development. The Easy API for simple transfers is coming in Phase 1.