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.

• 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

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

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"

#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);

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

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

                    ┌─────────────┐
                    │   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

Default features: http, http2, rustls, decompression.

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

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).

MIT