lgwks_std — zero-config primitives that replace a dozen crates

The standard library gets you 90% of the way. This crate is the last 10% — hex, base64, timestamps, UUIDs, hashing, glob matching, regex, JSON, HTTP, tracing, async — as single-import, zero-config calls, each behind one audited dependency stack. No transitive surprises, no feature flag archaeology.

Pick exactly what you need. The default build is core plus trace; every other capability is one feature with one vetted stack beneath it.

trace is default-on because the estate's PRINTS rule forbids println! in library code and names tracing as the replacement — a rule that names an unavailable facility is not a rule. It costs four small crates (tracing, tracing-core, pin-project-lite, once_cell), with no proc macro and no syn. Want a genuinely zero-dependency build?

cargo add lgwks_std --no-default-features --features core

That is the only configuration in which this crate pulls nothing at all, and it is measured, not asserted: cargo tree -p lgwks_std --no-default-features --features core -e normal prints one line — lgwks_std itself.

Package lgwks_std (underscore) lives in directory crates/lgwks-std (hyphen): cargo add lgwks_std then use lgwks_std::....

Install

cargo add lgwks_std                                    # core + trace
cargo add lgwks_std --features json,http               # pick what you need
cargo add lgwks_std --no-default-features --features core   # zero deps
cargo run -p lgwks_std --example quickstart            # 10-line tour (this repo)

Usage

// Core — zero external deps, always available
use lgwks_std::{hex, time, encoding, glob};

let digest = hex::encode(b"hello");
let now = time::now_rfc3339();
let encoded = encoding::base64::encode(b"payload");
let matches = glob::matches("src/**/*.rs", "src/lib.rs");

// Opt-in features — each adds exactly one vetted dependency
use lgwks_std::id::Uuid;       // feature = "random"
use lgwks_std::hash;            // feature = "hash"
use lgwks_std::pattern::Regex;  // feature = "pattern"
use lgwks_std::json;            // feature = "json"

let id = Uuid::new_v4().expect("OS entropy");
let blake3 = hash::blake3(b"content-addressable");
let re = Regex::new(r"\d+").expect("valid regex");

#[derive(json::Serialize, json::Deserialize)]
#[serde(crate = "lgwks_std::json::serde")]
struct Point { x: i32, y: i32 }

let point: Point = json::from_str(r#"{"x":1,"y":2}"#).expect("valid JSON");

The #[serde(crate = ...)] line is required, not optional. serde's derive macro resolves a crate named serde; the gate forbids consumers from declaring serde directly (it is owned by lgwks_std), so the attribute points the expansion at the re-export instead. If the compiler says cannot find - serde in this scope, add the attribute — do NOT cargo add serde; lgwks-deps check will refuse that edge.

Feature map

[dependencies]
lgwks_std = "0.6"                       # core only, zero deps
lgwks_std = { version = "0.6", features = ["hash", "json"] }  # pick what you need
lgwks_std = { version = "0.6", features = ["full"] }           # everything

Module reference

Dependency philosophy

Every direct dependency is a vetted leaf or single-purpose stack registered by semantic capability and owner. lgwks-deps check audits authored edges from Cargo metadata; Cargo.lock preserves the exact transitive provenance.

• blake3 — 3 zero-dep leaves (arrayvec, cfg-if, constant_time_eq)
• regex — 4 BurntSushi-internal crates, zero external deps
• serde — derive stack (proc-macro2, quote, syn)
• serde_json — 2 leaves beyond serde (itoa, ryu)
• ron — 1 leaf beyond serde (bitflags)
• rkyv — 5 djkoloski crates, zero external deps
• getrandom — zero deps in std-only mode
• ureq — blocking HTTP client, rustls-only TLS stack plus small leaves
• iri-string — zero-dep URI validation leaf at default features
• rustix — safe POSIX syscall surface for the fs-raw primitive; Unix-only, optional
• tracing — 4 crates (tracing, tracing-core, pin-project-lite, once_cell), no proc macro because attributes is off. Default-on: the PRINTS rule forbids println! in library code and names tracing as the replacement, so the facility has to be reachable.

core alone carries zero external dependencies; the default build is core plus trace. You choose what you pull in; every other feature flag is one capability, one stack, no surprises.

Minimum supported Rust version

Rust 1.98.0. The MSRV moves forward only when code or dependency requirements demand it.

License

Apache-2.0 — Copyright 2026 Logical Works Incorporated