sorug

sorug is an ultra-high-performance, zero-copy, WHATWG URL Living Standard-compliant URL parser written in Rust. It targets production parsers that need correctness and nanosecond-scale throughput — and currently outperforms both servo/rust-url and ada-url on the hot paths that matter.

Why sorug?

Benchmarks

Criterion, Linux, release profile (lto = true, codegen-units = 1). Lower is better (nanoseconds / parse). Measured 2026-08-04.

Reproduce locally:

cargo bench --bench url_benchmark

Numbers are indicative. Absolute values vary by CPU; relative ordering is what we track. IDNA uses an in-tree UTS #46 path with a Latin-1/CJK/kana/Hangul identity fast path; membership tables are built from vendored Unicode UCD (no ICU/idna crate).

Quick start

cargo add sorug

[dependencies]
sorug = "0.3"

use sorug::Url;

fn main() -> Result<(), sorug::ParseError> {
    let url = Url::parse("https://example.com/path?q=1#frag")?;
    assert_eq!(url.scheme(), "https");
    assert_eq!(url.host(), Some("example.com"));
    assert_eq!(url.as_str(), "https://example.com/path?q=1#frag");
    assert_eq!(url.origin().serialized(), "https://example.com");
    Ok(())
}

Relative resolution with join / make_relative:

use sorug::Url;

let base = Url::parse("https://example.com/dir/page")?;
let joined = base.join("../other")?;
assert_eq!(joined.as_str(), "https://example.com/other");

let target = Url::parse("https://example.com/dir/x")?;
assert_eq!(base.make_relative(&target).as_deref(), Some("x"));

Mutate components (WHATWG / WPT setters) and edit the query as form-urlencoded pairs:

use sorug::{SearchParams, Url};

let mut url = Url::parse("https://example.com/old")?;
url.set_pathname("/api/v1");
url.set_search("?q=1");
assert_eq!(url.href(), "https://example.com/api/v1?q=1");

let mut params = SearchParams::parse("q=1");
params.append("lang", "tr");
url.set_search_params(&params);
assert_eq!(url.search(), "?q=1&lang=tr");

Features

# no_std + alloc
sorug = { version = "0.3", default-features = false }

# with serde
sorug = { version = "0.3", features = ["serde"] }

# with http::Uri bridge
sorug = { version = "0.3", features = ["http"] }

http feature example:

use http::Uri;
use sorug::Url;

let url = Url::parse("https://example.com/api").unwrap();
let uri: Uri = url.to_uri().unwrap();
let back = sorug::uri_to_url(&uri).unwrap();
assert_eq!(back.as_str(), "https://example.com/api");

Git dependency (tracking main):

[dependencies]
sorug = { git = "https://github.com/hocestnonsatis/sorug" }

Current Status & Roadmap

Today (0.3.0 on crates.io)

• Relative URL ops: join / make_relative / path_segments / path_segments_mut / query_pairs(_mut).
• Typed Host (+ Host::parse), rust-url-shaped getters (authority, domain, port, …), Hash / Ord, optional serde / http, no_std + alloc.
• IDNA: in-tree Punycode + UTS #46; membership tables from vendored Unicode UCD 16.0.0 + data/idna_overlay.txt (Node/WPT).
• WPT parser: 891 / 891; WPT setters: 278 / 278.
• Docs: docs.rs/sorug.

Next

• Continue refining toward a future 1.0 (no API freeze yet).
• Differential fuzzing against rust-url where intentional divergences are documented.

C FFI

Optional C bindings live in ffi/ (sorug-ffi, workspace member, not on crates.io yet). The main crate stays forbid(unsafe_code); the FFI package is the C ABI boundary (cdylib / staticlib). See ffi/README.md.

Not goals (for now)

• Matching every historical quirk of non-WHATWG parsers.
• Trading forbid(unsafe_code) for micro-wins.

Design sketch

• Index-based record — component boundaries are u32 offsets into the WHATWG href serialization.
• Lazy / CoW serialization — borrow when input is already canonical; upgrade to owned on mutation.
• Strict state machine — transitions follow the URL Living Standard basic URL parser.

Testing

cargo test                 # unit + integration (incl. WPT + comprehensive validation)
cargo test --all-features  # includes serde / http
cargo test --workspace     # includes sorug-ffi
cargo test --test api_maturity       # Hash/Ord, getters, query_pairs, set_port
cargo test --test path_segments_mut  # PathSegmentsMut vs rust-url
cargo check --no-default-features  # no_std + alloc
cargo test --test wpt      # WPT urltestdata only
cargo test --test wpt_setters  # WPT setters_tests only
cargo bench                # Criterion vs ada-url and servo/url

See CONTRIBUTING.md for policies, style, and review expectations.

License

Licensed under either of

• Apache License, Version 2.0
• MIT license

at your option.

Code of Conduct

Participation is governed by our Code of Conduct.