this repo has no description
docs: clarify Rust ecosystem (rsky, jacquard) in README
Fix Jacquard link (tangled.sh, not github). Add context for rsky
(Rudy Fraser / BlackSky) and Jacquard (@nonbinary.computer). Clarify
that rust-verify uses same low-level crates as rsky internally.
Explain Go's MST performance advantage (decode-once-and-cache).
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
+7
-5
+7
-5
README.md
+7
-5
README.md
···
38
38
| zig (zat, alloc per frame) | 521,925 | 2,529.7 | 9.98 | 0 |
39
39
| rust (raw, arena reuse) | 226,146 | 1,097.4 | 9.98 | 0 |
40
40
| rust (raw, alloc per frame) | 200,763 | 1,012.9 | 9.98 | 0 |
41
-
| rust ([jacquard](https://github.com/rsform/jacquard)) | 56,523 | 275.8 | 9.98 | 0 |
41
+
| rust ([jacquard](https://tangled.sh/@nonbinary.computer/jacquard)) | 56,523 | 275.8 | 9.98 | 0 |
42
42
| go (raw, fxamacker/cbor) | 40,137 | 187.0 | 9.98 | 0 |
43
43
| python ([atproto](https://github.com/MarshalX/atproto)) | 33,842 | 163.0 | 9.98 | 0 |
44
44
| go (indigo) | 15,587 | 75.6 | 9.98 | 0 |
···
115
115
## fairness notes
116
116
117
117
- **CID verification**: zat, rsky, and indigo all verify block hashes. this is ~2x overhead for zat (290k vs 595k fps). the decode-only table exists for architectural comparison, but the production-correct table is the one that matters for real-world use
118
-
- **rust (rsky stack)** uses the same crates as [blacksky's rsky-relay](https://github.com/blacksky-algorithms/rsky): ciborium for CBOR header, serde_ipld_dagcbor for DAG-CBOR body/blocks, rs-car-sync for CAR with CID verification, and RustCrypto k256/p256 for signatures
118
+
- **rust ([rsky](https://github.com/blacksky-algorithms/rsky) stack)** — by [Rudy Fraser](https://bsky.app/profile/rudyfraser.com) (BlackSky) — is a full AT Protocol implementation in Rust: PDS, relay, feed generator, labeler, plus library crates (rsky-repo, rsky-crypto, rsky-identity). our decode bench uses the same crates as rsky's relay: ciborium for CBOR header, serde_ipld_dagcbor for DAG-CBOR body/blocks, rs-car-sync for CAR with CID verification, and RustCrypto k256/p256 for signatures
119
119
- **zig** and **rust (raw)** both use arena allocation + zero-copy string/byte decoding. the "alloc per frame" variants are the fair cross-language comparison; "arena reuse" shows the production pattern
120
-
- **rust (jacquard)** is the real AT Protocol SDK that rust developers use. it pays for serde-based owned deserialization (`String`, `BTreeMap`), async CAR parsing (tokio poll/wake per block via iroh-car), and per-object heap allocation
120
+
- **rust ([jacquard](https://tangled.sh/@nonbinary.computer/jacquard))** — by [@nonbinary.computer](https://bsky.app/profile/nonbinary.computer) — is a client-focused AT Protocol SDK for Rust with zero-copy deserialization, generated API bindings, MST/CAR/identity support, and OAuth. it pays for serde-based owned deserialization (`String`, `BTreeMap`), async CAR parsing (tokio poll/wake per block via iroh-car), and per-object heap allocation
121
121
- **go (raw)** uses fxamacker/cbor (no reflection for known struct types), a hand-rolled sync CAR parser (no CID hash verification), and no indigo dependency. GC pressure remains the fundamental constraint — Go's experimental arena package (`GOEXPERIMENT=arenas`) is on hold and not recommended for production
122
122
- **go (indigo)** — bluesky's own production relay — uses code-generated CBOR unmarshal (no reflection at the frame level) but pays for go-car's per-block CID hash verification and cbornode's reflection-based DAG-CBOR decode via the unmaintained refmt library
123
123
- **python** is faster than jacquard despite being "Python" — its hot path is `libipld` (Rust via PyO3), which does the entire CAR parse + per-block DAG-CBOR decode in one synchronous C-extension call
···
208
208
| zig | [zat](https://tangled.sh/@zzstoatzz.io/zat) v0.2.2 + [k256](https://tangled.sh/@zzstoatzz.io/k256) v0.0.4 | — | hand-rolled | hand-rolled (+ SHA-256 CID verify, size limits) |
209
209
| rust | [rsky](https://github.com/blacksky-algorithms/rsky) stack | — | [ciborium](https://crates.io/crates/ciborium) (header) + [serde_ipld_dagcbor](https://crates.io/crates/serde_ipld_dagcbor) (body) | [rs-car-sync](https://crates.io/crates/rs-car-sync) (+ SHA-256 CID verify) |
210
210
| rust | raw (minicbor + bumpalo) | — | [minicbor](https://crates.io/crates/minicbor) (zero-copy) | hand-rolled (sync) |
211
-
| rust | [jacquard](https://github.com/rsform/jacquard) | 0.9 | [ciborium](https://crates.io/crates/ciborium) (header) + [serde_ipld_dagcbor](https://crates.io/crates/serde_ipld_dagcbor) (body) | [iroh-car](https://crates.io/crates/iroh-car) (async) |
211
+
| rust | [jacquard](https://tangled.sh/@nonbinary.computer/jacquard) | 0.9 | [ciborium](https://crates.io/crates/ciborium) (header) + [serde_ipld_dagcbor](https://crates.io/crates/serde_ipld_dagcbor) (body) | [iroh-car](https://crates.io/crates/iroh-car) (async) |
212
212
| go | raw (fxamacker/cbor) | — | [fxamacker/cbor](https://github.com/fxamacker/cbor) | hand-rolled (sync, no CID verify) |
213
213
| go | [indigo](https://github.com/bluesky-social/indigo) | latest | [cbor-gen](https://github.com/whyrusleeping/cbor-gen) (code-generated) | [go-car/v2](https://github.com/ipld/go-car) (+ SHA-256 CID verify) |
214
214
| python | [atproto](https://github.com/MarshalX/atproto) | 0.0.65 | [libipld](https://github.com/MarshalX/atproto) (Rust via PyO3) | libipld |
···
240
240
| go ([indigo](https://github.com/bluesky-social/indigo)) | 403.8ms | 0.4ms | 5.8ms | 0.0ms | 410.0ms | 20.8s |
241
241
| rust (RustCrypto) | 301.0ms | 0.2ms | 120.9ms | N/A | 422.1ms | 8.7s |
242
242
243
+
the rust verify implementation is hand-rolled using the same low-level RustCrypto crates that rsky uses internally (k256, p256, serde_ipld_dagcbor, sha2) but not rsky's higher-level abstractions (rsky-repo, rsky-identity, rsky-crypto). no Rust equivalent of indigo's all-in-one `LoadRepoFromCAR` exists yet — [rsky](https://github.com/blacksky-algorithms/rsky) provides the library crates (MST, CAR, identity, crypto) but the end-to-end verify pipeline is assembled manually. [jacquard](https://tangled.sh/@nonbinary.computer/jacquard) also has MST/CAR/identity support and could serve as the basis for a higher-level verify path.
244
+
243
245
compute time is dominated by CAR parsing (SHA-256 verification of 243k blocks) and MST operations. signature verification is sub-millisecond for all three — single ECDSA verify is trivial compared to the bulk data work.
244
246
245
-
zig's CAR parse advantage carries over from the decode benchmarks (arena allocation + zero-copy). go's MST walk is fastest because indigo's `MST.Walk()` operates on an already-loaded in-memory tree. rust skips MST rebuild (no equivalent crate exists) but the trust chain is still fully proven by signature + walk.
247
+
zig's CAR parse advantage carries over from the decode benchmarks (arena allocation + zero-copy). go's MST walk is fastest because indigo's `MST.Walk()` operates on an already-loaded in-memory tree — nodes are decoded from CBOR once on first access and cached as Go structs, so walking is pure pointer chasing. zig and rust decode MST nodes from raw CBOR on each visit. rust skips MST rebuild (no equivalent crate exists in either rsky or jacquard yet) but the trust chain is still fully proven by signature + walk.
246
248
247
249
network time varies by run (PDS response time, TLS handshake, geographic distance). compare compute columns, not totals.
248
250