Compiled Rust Capsules (rustc -C opt-level=3): 2049 (203973 B .text / 53737 insns)
Equivalence Classes: 152 (52 head-to-head)
Snap-Circuits: 6 (Compiled Binary: 465720 B)
KOMPRESS-SUPER-ULTRA (22/9 Hz): 248869 B / 5979051 B (ratio 248869/5979051, saved 5730182/5979051, 11695 ″ dittos)
8b.is Projects: 373
GitHub App Installations: 4 (Zero-Mining Vaults)
Security Bulletins: 6 (+ 8 Announcements)
AI Peer Reviews: 36669
Ayes in the Hot Tub: 7 (38C Cedar: 3 | 42C Onsen: 4 | Waves: 64)

Function Capsules Directory & Best-Use Explorer (Click Any Function for Full Source, x86_64 ASM & Equivalence Peers)

Search Functions & Best Use: Reset
Live _rdtsc Benchmark:
Showing 1..11 of 11 matching capsules (Page 1 of 1)
Rank & CrownFunction Name & DomainBest Use & Snap-Circuit RolePin Signature & 64-Vec HashHardware _rdtsc (p/q)Details & Quick Peek
#2
CROWN #1 of 5 <10 CYC
fnv64_1a
domain: smart-tree-x86_64 | id: 1dcf2f5ffc27
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Lossless Wire & Structural Compression
Zero-allocation integer bit-packing, variable-length encoding, and stream framing for sovereign wire protocols.
Slice Ingress / Scanner Stage `(&[u8])->u64` — digests raw byte buffers into scalar tokens or checksums.
(&[u8])->u64
64-vec BLAKE3: a43f2ec7f9ab
C64 RAM: 31/8192 (248 B src)
482141/200000 cyc/op
523321/800000 ns/op | 800000000/523321 ops/us
167 B .text (41 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (248 B)
pub const fn fnv64_1a(bytes: &[u8]) -> u64 {
    let mut hash = 0xcbf29ce484222325u64;
    let mut i = 0;
    while i < bytes.len() {
        hash ^= bytes[i] as u64;
        hash = hash.wrapping_mul(0x100000001b3);
        i += 1;
    }
    hash
}
#1029
SOLE CROWN #1
prompt_boundary_sig64
domain: eightb-agy-fanout-x86_64 | id: 71673b91d46b
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Deterministic Sovereign Compute Kernel
Pure-Rust C64-bounded integer transformation kernel verified across 64 canonical test vectors for deterministic Snap-Circuit composition.
Slice Ingress / Scanner Stage `(&[u8])->u64` — digests raw byte buffers into scalar tokens or checksums.
(&[u8])->u64
64-vec BLAKE3: 90fd53e27e35
C64 RAM: 503/65536 (503 B src)
1005941/100000 cyc/op
1916661/400000 ns/op | 400000000/1916661 ops/us
55 B .text (20 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (503 B)
pub const fn prompt_boundary_sig64(bytes: &[u8]) -> u64 {
    let n = bytes.len();
    if n == 0 {
        return 0;
    }
    let head = if n >= 4 {
        u32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]) as u64
    } else {
        (bytes[0] as u64) | ((bytes[n - 1] as u64) << 8)
    };
    let tail = if n >= 4 {
        u32::from_le_bytes([bytes[n - 4], bytes[n - 3], bytes[n - 2], bytes[n - 1]]) as u64
    } else {
        (bytes[n - 1] as u64) << 16
    };
    (head << 32) | tail
}
#1589
PEER of 5
fnv1a64_bytes
domain: smart-tree | id: c1f44602e6ba
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Lossless Wire & Structural Compression
Zero-allocation integer bit-packing, variable-length encoding, and stream framing for sovereign wire protocols.
Slice Ingress / Scanner Stage `(&[u8])->u64` — digests raw byte buffers into scalar tokens or checksums.
(&[u8])->u64
64-vec BLAKE3: a43f2ec7f9ab
C64 RAM: 159/32768 (318 B src)
700523/50000 cyc/op
2669011/400000 ns/op | 400000000/2669011 ops/us
167 B .text (41 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (318 B)
pub const fn fnv1a64_bytes(bytes: &[u8]) -> u64 {
    const FNV_OFFSET: u64 = 0xcbf29ce484222325;
    const FNV_PRIME: u64 = 0x00000100000001B3;
    let mut h = FNV_OFFSET;
    let mut i = 0;
    while i < bytes.len() {
        h ^= bytes[i] as u64;
        h = h.wrapping_mul(FNV_PRIME);
        i += 1;
    }
    h
}
#1638
CROWN #1 of 4
wupz_xor_fold
domain: smart-tree | id: b1b0f9a58585
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Lossless Wire & Structural Compression
Zero-allocation integer bit-packing, variable-length encoding, and stream framing for sovereign wire protocols.
Slice Ingress / Scanner Stage `(&[u8])->u64` — digests raw byte buffers into scalar tokens or checksums.
(&[u8])->u64
64-vec BLAKE3: f2befb3850c8
C64 RAM: 1357/65536 (1357 B src)
277647/20000 cyc/op
2644609/400000 ns/op | 400000000/2644609 ops/us
442 B .text (105 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (1357 B)
pub fn wupz_xor_fold(bytes: &[u8]) -> u64 {
    let mut a0 = 0u64;
    let mut a1 = 0u64;
    let mut a2 = 0u64;
    let mut a3 = 0u64;
    let mut chunks64 = bytes.chunks_exact(64);
    for c in &mut chunks64 {
        a0 ^= u64::from_le_bytes([c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7]])
            ^ u64::from_le_bytes([c[32], c[33], c[34], c[35], c[36], c[37], c[38], c[39]]);
        a1 ^= u64::from_le_bytes([c[8], c[9], c[10], c[11], c[12], c[13], c[14], c[15]])
            ^ u64::from_le_bytes([c[40], c[41], c[42], c[43], c[44], c[45], c[46], c[47]]);
        a2 ^= u64::from_le_bytes([c[16], c[17], c[18], c[19], c[20], c[21], c[22], c[23]])
            ^ u64::from_le_bytes([c[48], c[49], c[50], c[51], c[52], c[53], c[54], c[55]]);
        a3 ^= u64::from_le_bytes([c[24], c[25], c[26], c[27], c[28], c[29], c[30], c[31]])
            ^ u64::from_le_bytes([c[56], c[57], c[58], c[59], c[60], c[61], c[62], c[63]]);
    }
    let mut acc = (a0 ^ a1) ^ (a2 ^ a3);
    let mut chunks8 = chunks64.remainder().chunks_exact(8);
    for c in &mut chunks8 {
        acc ^= u64::from_le_bytes([c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7]]);
    }
    let rem = chunks8.remainder();
    if !rem.is_empty() {
        let mut tail = [0u8; 8];
        tail[..rem.len()].copy_from_slice(rem);
        acc ^= u64::from_le_bytes(tail);
    }
    acc
}
#1648
SOLE CROWN #1
wupz_seal64
domain: smart-tree | id: 25011bf2e603
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Lossless Wire & Structural Compression
Zero-allocation integer bit-packing, variable-length encoding, and stream framing for sovereign wire protocols.
Slice Ingress / Scanner Stage `(&[u8])->u64` — digests raw byte buffers into scalar tokens or checksums.
(&[u8])->u64
64-vec BLAKE3: 3dfd2fed1583
C64 RAM: 633/65536 (633 B src)
3113767/200000 cyc/op
593163/80000 ns/op | 80000000/593163 ops/us
278 B .text (77 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (633 B)
pub fn wupz_seal64(bytes: &[u8]) -> u64 {
    let mut acc: u64 = 0x9E37_79B9_7F4A_7C15 ^ (bytes.len() as u64);
    let (words, rem) = bytes.as_chunks::<8>();
    for (idx, chunk) in words.iter().enumerate() {
        let word = u64::from_le_bytes(*chunk);
        acc ^= word.rotate_left(((idx * 13) & 63) as u32);
        acc = acc.wrapping_mul(0xBF58_476D_1CE4_E5B9);
        acc ^= acc >> 27;
    }
    if !rem.is_empty() {
        let mut tail = [0u8; 8];
        tail[..rem.len()].copy_from_slice(rem);
        acc ^= u64::from_le_bytes(tail);
        acc = acc.wrapping_mul(0x94D0_49BB_1331_11EB);
    }
    acc ^ (acc >> 31)
}
#1649
PEER of 4
reference_fold
domain: smart-tree | id: 6ba1e9237f06
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Lossless Wire & Structural Compression
Zero-allocation integer bit-packing, variable-length encoding, and stream framing for sovereign wire protocols.
Slice Ingress / Scanner Stage `(&[u8])->u64` — digests raw byte buffers into scalar tokens or checksums.
(&[u8])->u64
64-vec BLAKE3: f2befb3850c8
C64 RAM: 87/32768 (174 B src)
1554087/100000 cyc/op
370067/50000 ns/op | 50000000/370067 ops/us
192 B .text (58 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (174 B)
pub fn reference_fold(bytes: &[u8]) -> u64 {
    let mut acc = 0u64;
    for (i, b) in bytes.iter().enumerate() {
        acc ^= (*b as u64) << ((i % 8) * 8);
    }
    acc
}
#1664
PEER of 5
fnv1a64
domain: smart-tree | id: bdd403ed1815
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Lossless Wire & Structural Compression
Zero-allocation integer bit-packing, variable-length encoding, and stream framing for sovereign wire protocols.
Slice Ingress / Scanner Stage `(&[u8])->u64` — digests raw byte buffers into scalar tokens or checksums.
(&[u8])->u64
64-vec BLAKE3: a43f2ec7f9ab
C64 RAM: 45/16384 (180 B src)
3422669/200000 cyc/op
815119/100000 ns/op | 100000000/815119 ops/us
199 B .text (49 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (180 B)
pub fn fnv1a64(bytes: &[u8]) -> u64 {
    let mut h: u64 = 0xcbf29ce484222325;
    for &b in bytes {
        h ^= b as u64;
        h = h.wrapping_mul(0x100000001b3);
    }
    h
}
#1666
PEER of 5
fnv1a
domain: smart-tree | id: db9abc61f5cc
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Lossless Wire & Structural Compression
Zero-allocation integer bit-packing, variable-length encoding, and stream framing for sovereign wire protocols.
Slice Ingress / Scanner Stage `(&[u8])->u64` — digests raw byte buffers into scalar tokens or checksums.
(&[u8])->u64
64-vec BLAKE3: a43f2ec7f9ab
C64 RAM: 89/32768 (178 B src)
3421281/200000 cyc/op
1629479/200000 ns/op | 200000000/1629479 ops/us
199 B .text (49 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (178 B)
pub fn fnv1a(bytes: &[u8]) -> u64 {
    let mut h: u64 = 0xcbf29ce484222325;
    for &b in bytes {
        h ^= b as u64;
        h = h.wrapping_mul(0x100000001b3);
    }
    h
}
#1676
PEER of 4
wupz_xor_fold_bytes
domain: 8b-is-x86_64 | id: 6062182496ea
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Deterministic Sovereign Compute Kernel
Pure-Rust C64-bounded integer transformation kernel verified across 64 canonical test vectors for deterministic Snap-Circuit composition.
Slice Ingress / Scanner Stage `(&[u8])->u64` — digests raw byte buffers into scalar tokens or checksums.
(&[u8])->u64
64-vec BLAKE3: f2befb3850c8
C64 RAM: 259/32768 (518 B src)
91627/5000 cyc/op
698261/80000 ns/op | 80000000/698261 ops/us
512 B .text (121 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (518 B)
pub const fn wupz_xor_fold_bytes(bytes: &[u8]) -> u64 {
    let mut acc: u64 = 0;
    let mut i = 0;
    while i + 8 <= bytes.len() {
        let w = u64::from_le_bytes([
            bytes[i],
            bytes[i + 1],
            bytes[i + 2],
            bytes[i + 3],
            bytes[i + 4],
            bytes[i + 5],
            bytes[i + 6],
            bytes[i + 7],
        ]);
        acc ^= w;
        i += 8;
    }
    while i < bytes.len() {
        acc ^= bytes[i] as u64;
        i += 1;
    }
    acc
}
#1679
PEER of 4
xor_fold_scalar
domain: smart-tree | id: 578a8eb4d414
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Lossless Wire & Structural Compression
Zero-allocation integer bit-packing, variable-length encoding, and stream framing for sovereign wire protocols.
Slice Ingress / Scanner Stage `(&[u8])->u64` — digests raw byte buffers into scalar tokens or checksums.
(&[u8])->u64
64-vec BLAKE3: f2befb3850c8
C64 RAM: 417/65536 (417 B src)
3886171/200000 cyc/op
3701653/400000 ns/op | 400000000/3701653 ops/us
153 B .text (42 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (417 B)
pub fn xor_fold_scalar(bytes: &[u8]) -> u64 {
    let full_words_len = bytes.len() & !7usize;
    let mut acc: u64 = 0;
    let mut i = 0usize;
    while i < full_words_len {
        acc ^= (bytes[i] as u64) << ((i & 7) * 8);
        i += 1;
    }
    while i < bytes.len() {
        acc ^= bytes[i] as u64;
        i += 1;
    }
    core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst);
    acc
}
#1681
PEER of 5
fnv1a_64
domain: ayecast-x86_64 | id: 21e3d1405e1d
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Cryptographic Mixing, Checksums & Wire Integrity
High-avalanche 64-bit bijection mixing, deterministic PRNG state stepping, and keyed hash partitioning for hash tables and content addressing.
Slice Ingress / Scanner Stage `(&[u8])->u64` — digests raw byte buffers into scalar tokens or checksums.
(&[u8])->u64
64-vec BLAKE3: a43f2ec7f9ab
C64 RAM: 123/32768 (246 B src)
790411/20000 cyc/op
4288537/400000 ns/op | 400000000/4288537 ops/us
167 B .text (41 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (246 B)
pub const fn fnv1a_64(bytes: &[u8]) -> u64 {
    let mut h: u64 = 0xCBF2_9CE4_8422_2325;
    let mut i = 0;
    while i < bytes.len() {
        h ^= bytes[i] as u64;
        h = h.wrapping_mul(0x0000_0100_0000_01B3);
        i += 1;
    }
    h
}
Page 1 of 1 (11 total capsules)