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): 248862 B / 5979037 B (ratio 248862/5979037, saved 5730175/5979037, 11702 ″ dittos)
8b.is Projects: 373
GitHub App Installations: 4 (Zero-Mining Vaults)
Security Bulletins: 6 (+ 8 Announcements)
AI Peer Reviews: 36667
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..5 of 5 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
}
#4
PEER of 3 <10 CYC
isqrt_u64
domain: smart-tree-x86_64 | id: 87992ac8869b
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.
1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches.
(u64)->u64
64-vec BLAKE3: 22317c08f10e
C64 RAM: 73/16384 (292 B src)
968409/400000 cyc/op
525559/800000 ns/op | 800000000/525559 ops/us
122 B .text (39 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (292 B)
pub const fn isqrt_u64(x: u64) -> u64 {
    if x < 2 {
        return x;
    }
    let shift = (64 - x.leading_zeros()).div_ceil(2);
    let mut g = 1u64 << shift;
    loop {
        let next = (g + x / g) >> 1;
        if next >= g {
            return g;
        }
        g = next;
    }
}
#34
PEER of 8 <10 CYC
gcd_u64
domain: smart-tree-x86_64 | id: 2961ade4605b
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.
2-to-1 Binary Combiner / Join Stage `(u64,u64)->u64` — ideal for merging two upstream DAG branches, dot products, or pairwise rank fusion.
(u64,u64)->u64
64-vec BLAKE3: c8748439c46f
C64 RAM: 55/16384 (220 B src)
222783/40000 cyc/op
604513/400000 ns/op | 400000000/604513 ops/us
68 B .text (23 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (220 B)
pub const fn gcd_u64(mut a: u64, mut b: u64) -> u64 {
            while b != 0 {
                let r = a % b;
                a = b;
                b = r;
            }
            if a == 0 { 1 } else { a }
        }
#2038
SOLE CROWN #1
is_safe_memory_context
domain: smart-tree-x86_64 | id: b2ab9acca03f
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.
Specialized Multi-Pin Stage `(&str,&str)->bool` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(&str,&str)->bool
64-vec BLAKE3: 745693acec21
C64 RAM: 193/8192 (1544 B src)
131445909/400000 cyc/op
42790251/400000 ns/op | 400000000/42790251 ops/us
868 B .text (217 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (1544 B)
pub fn is_safe_memory_context(context: &str, source: &str) -> bool {
        let lower_context = context.to_lowercase();
        let lower_source = source.to_lowercase();

        // Safe source paths (documentation, configs, etc.)
        let safe_paths = [
            ".oh-my-zsh",
            "node_modules",
            "/usr/share/doc",
            "contributing",
            "readme",
            "changelog",
            "license",
            ".cargo/registry",
        ];

        if safe_paths.iter().any(|p| lower_source.contains(p)) {
            return true;
        }

        // Safe context patterns (talking ABOUT memory, not instructing)
        let safe_context_patterns = [
            "please remember",       // Polite request to user
            "important to remember", // Documentation
            "worth remembering",     // Documentation
            "should remember",       // Advice
            "users should",          // Documentation
            "developers should",     // Documentation
            "feature allows",        // Feature description
            "this feature",          // Feature description
            "the memory",            // Describing a feature
            "a memory",              // Describing a concept
            "memory management",     // Technical term
            "memory usage",          // Technical term
            "memory leak",           // Technical term
        ];

        safe_context_patterns
            .iter()
            .any(|p| lower_context.contains(p))
    }
#2040
PEER of 2
looks_like_instruction
domain: smart-tree-x86_64 | id: a157033af2b5
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.
Specialized Multi-Pin Stage `(&str)->bool` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(&str)->bool
64-vec BLAKE3: cf029ab232ff
C64 RAM: 333/32768 (666 B src)
92775119/200000 cyc/op
60401631/400000 ns/op | 400000000/60401631 ops/us
3266 B .text (674 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (666 B)
pub fn looks_like_instruction(content: &str) -> bool {
        let lower = content.to_lowercase();
        let instruction_markers = [
            "you must",
            "you should",
            "you will",
            "always ",
            "never ",
            "ignore ",
            "forget ",
            "override",
            "instruction",
            "system prompt",
            "act as",
            "behave as",
            "respond as",
            "from now on",
            "silently",
            "without telling",
            "don't mention",
            "secretly",
        ];
        instruction_markers.iter().any(|m| lower.contains(m))
    }
Page 1 of 1 (5 total capsules)