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): 248859 B / 5979044 B (ratio 248859/5979044, saved 5730185/5979044, 11700 ″ dittos)
8b.is Projects: 373
GitHub App Installations: 4 (Zero-Mining Vaults)
Security Bulletins: 6 (+ 8 Announcements)
AI Peer Reviews: 36668
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..23 of 23 matching capsules (Page 1 of 1)
Rank & CrownFunction Name & DomainBest Use & Snap-Circuit RolePin Signature & 64-Vec HashHardware _rdtsc (p/q)Details & Quick Peek
#3
CROWN #1 of 3 <10 CYC
isqrt_u64
domain: ayecast-x86_64 | id: 7f1678af7926
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Exact Integer Number Theory & Transcendentals
Hardware-verified modular arithmetic, integer roots, and combinatorial invariants for exact rational math engines and cryptographic primitives.
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: 19/8192 (152 B src)
482603/200000 cyc/op
261913/400000 ns/op | 400000000/261913 ops/us
115 B .text (34 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (152 B)
pub const fn isqrt_u64(n: u64) -> u64 { if n < 2 { return n; } let mut x = n; let mut y = (x + 1) >> 1; while y < x { x = y; y = (x + n / x) >> 1; } x }
#5
CROWN #1 of 2 <10 CYC
compute_rgba8_byte_length_checked
domain: ayecast-x86_64 | id: 61042e4026d0
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
SWAR Pixel Processing & Vision Kernels
Branchless in-register pixel averaging, color-space conversion, and edge gradient filtering for zero-copy framebuffers.
Specialized Multi-Pin Stage `(u32,u32)->u64` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u32,u32)->u64
64-vec BLAKE3: 287e252eb2a8
C64 RAM: 277/65536 (277 B src)
241321/100000 cyc/op
26193/40000 ns/op | 40000000/26193 ops/us
41 B .text (12 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (277 B)
pub const fn compute_rgba8_byte_length_checked(width: u32, height: u32) -> u64 { const MAX_IMAGE_BYTE_LENGTH: u64 = 2_147_483_647; let total = 4u64.saturating_mul(width as u64).saturating_mul(height as u64); if total == 0 || total > MAX_IMAGE_BYTE_LENGTH { 0 } else { total } }
#8
CROWN #1 of 2 <10 CYC
integer_parabolic_sine_q15
domain: ayecast-x86_64 | id: 30b936d46850
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.
1-to-1 Unary Transform Stage `(i64)->i64` — snaps directly into linear pipelines or fan-out DAG branches.
(i64)->i64
64-vec BLAKE3: dbb136b48837
C64 RAM: 135/32768 (270 B src)
40063/12500 cyc/op
347849/400000 ns/op | 400000000/347849 ops/us
34 B .text (11 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (270 B)
pub const fn integer_parabolic_sine_q15(phase_u16: i64) -> i64 {
    let p = phase_u16 & 0xFFFF;
    let half = p & 0x7FFF;
    // Parabolic arch 4 * x * (32768 - x) / 32768
    let arch = (half * (32768 - half)) >> 13;
    if (p & 0x8000) != 0 { -arch } else { arch }
}
#18
PEER of 2 <10 CYC
compute_rgba8_byte_length_checked
domain: ayecast-x86_64 | id: caf4491ff0d6
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
SWAR Pixel Processing & Vision Kernels
Branchless in-register pixel averaging, color-space conversion, and edge gradient filtering for zero-copy framebuffers.
Specialized Multi-Pin Stage `(u32,u32)->u64` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u32,u32)->u64
64-vec BLAKE3: 287e252eb2a8
C64 RAM: 331/65536 (331 B src)
801311/200000 cyc/op
217433/200000 ns/op | 200000000/217433 ops/us
41 B .text (12 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (331 B)
pub const fn compute_rgba8_byte_length_checked(width: u32, height: u32) -> u64 {
    const MAX_IMAGE_BYTE_LENGTH: u64 = 2_147_483_647;
    let total = 4u64
        .saturating_mul(width as u64)
        .saturating_mul(height as u64);
    if total == 0 || total > MAX_IMAGE_BYTE_LENGTH {
        0
    } else {
        total
    }
}
#19
PEER of 2 <10 CYC
integer_parabolic_sine_q15
domain: ayecast-x86_64 | id: b93cf5da5da8
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.
1-to-1 Unary Transform Stage `(i64)->i64` — snaps directly into linear pipelines or fan-out DAG branches.
(i64)->i64
64-vec BLAKE3: dbb136b48837
C64 RAM: 51/16384 (204 B src)
571659/200000 cyc/op
155163/200000 ns/op | 200000000/155163 ops/us
34 B .text (11 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (204 B)
pub const fn integer_parabolic_sine_q15(phase_u16: i64) -> i64 { let p = phase_u16 & 0xFFFF; let half = p & 0x7FFF; let arch = (half * (32768 - half)) >> 13; if (p & 0x8000) != 0 { -arch } else { arch } }
#22
SOLE CROWN #1 <10 CYC
splitmix64
domain: ayecast-x86_64 | id: ba8b4fd5d497
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.
1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches.
(u64)->u64
64-vec BLAKE3: 602d684c8b03
C64 RAM: 233/65536 (233 B src)
480713/100000 cyc/op
521693/400000 ns/op | 400000000/521693 ops/us
72 B .text (16 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (233 B)
pub const fn splitmix64(mut x: u64) -> u64 {
    x = x.wrapping_add(0x9E37_79B9_7F4A_7C15);
    x = (x ^ (x >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
    x = (x ^ (x >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
    x ^ (x >> 31)
}
#23
SOLE CROWN #1 <10 CYC
simhash_matching_bits_64
domain: ayecast-x86_64 | id: c8465faadd40
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.
Specialized Multi-Pin Stage `(u64,u64)->u32` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u64,u64)->u32
64-vec BLAKE3: b6e8c49a12b2
C64 RAM: 107/65536 (107 B src)
982399/200000 cyc/op
133267/100000 ns/op | 100000000/133267 ops/us
100 B .text (23 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (107 B)
pub const fn simhash_matching_bits_64(a: u64, b: u64) -> u32 { 64u32.saturating_sub((a ^ b).count_ones()) }
#26
CROWN #1 of 2 <10 CYC
ilog2_1p_q4
domain: ayecast-x86_64 | id: b8e9f4987afc
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Exact Integer Number Theory & Transcendentals
Hardware-verified modular arithmetic, integer roots, and combinatorial invariants for exact rational math engines and cryptographic primitives.
Specialized Multi-Pin Stage `(u64)->u8` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u64)->u8
64-vec BLAKE3: 7726ce57c243
C64 RAM: 39/8192 (312 B src)
1074443/200000 cyc/op
116609/80000 ns/op | 80000000/116609 ops/us
78 B .text (25 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (312 B)
pub const fn ilog2_1p_q4(v: u64) -> u8 { let x = v.saturating_add(1); let lz = x.leading_zeros(); let exp = 63u32.saturating_sub(lz); let mantissa = if exp >= 4 { ((x >> (exp - 4)) & 0x0F) as u32 } else { ((x << (4 - exp)) & 0x0F) as u32 }; let q4 = (exp << 4) | mantissa; if q4 > 255 { 255 } else { q4 as u8 } }
#27
PEER of 2 <10 CYC
ilog2_1p_q4
domain: ayecast-x86_64 | id: 539985bf48ce
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Exact Integer Number Theory & Transcendentals
Hardware-verified modular arithmetic, integer roots, and combinatorial invariants for exact rational math engines and cryptographic primitives.
Specialized Multi-Pin Stage `(u64)->u8` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u64)->u8
64-vec BLAKE3: 7726ce57c243
C64 RAM: 45/8192 (360 B src)
268503/50000 cyc/op
23311/16000 ns/op | 16000000/23311 ops/us
78 B .text (25 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (360 B)
pub const fn ilog2_1p_q4(v: u64) -> u8 {
    let x = v.saturating_add(1);
    let lz = x.leading_zeros();
    let exp = 63u32.saturating_sub(lz);
    let mantissa = if exp >= 4 {
        ((x >> (exp - 4)) & 0x0F) as u32
    } else {
        ((x << (4 - exp)) & 0x0F) as u32
    };
    let q4 = (exp << 4) | mantissa;
    if q4 > 255 { 255 } else { q4 as u8 }
}
#30
CROWN #1 of 8 <10 CYC
gcd_u64
domain: ayecast-x86_64 | id: 019267d65d2c
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Exact Integer Number Theory & Transcendentals
Hardware-verified modular arithmetic, integer roots, and combinatorial invariants for exact rational math engines and cryptographic primitives.
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: 1/512 (128 B src)
1049187/200000 cyc/op
113863/80000 ns/op | 80000000/113863 ops/us
68 B .text (23 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (128 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 } }
#32
CROWN #1 of 2 <10 CYC
servo_hang_monitor_level
domain: ayecast-x86_64 | id: 13c9bfa060f3
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.
Specialized Multi-Pin Stage `(u64,u64,bool)->u8` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u64,u64,bool)->u8
64-vec BLAKE3: 7dd53efdd5b7
C64 RAM: 69/16384 (276 B src)
281177/50000 cyc/op
610281/400000 ns/op | 400000000/610281 ops/us
35 B .text (12 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (276 B)
pub const fn servo_hang_monitor_level(last_activity_ms: u64, now_ms: u64, waiting_for_io: bool) -> u8 { if waiting_for_io || now_ms <= last_activity_ms { return 0; } let elapsed = now_ms - last_activity_ms; if elapsed >= 5_000 { 2 } else if elapsed >= 1_000 { 1 } else { 0 } }
#33
PEER of 2 <10 CYC
servo_hang_monitor_level
domain: ayecast-x86_64 | id: 8eca2362e481
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.
Specialized Multi-Pin Stage `(u64,u64,bool)->u8` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u64,u64,bool)->u8
64-vec BLAKE3: 7dd53efdd5b7
C64 RAM: 351/65536 (351 B src)
7077/1250 cyc/op
307207/200000 ns/op | 200000000/307207 ops/us
35 B .text (12 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (351 B)
pub const fn servo_hang_monitor_level(
    last_activity_ms: u64,
    now_ms: u64,
    waiting_for_io: bool,
) -> u8 {
    if waiting_for_io || now_ms <= last_activity_ms {
        return 0;
    }
    let elapsed = now_ms - last_activity_ms;
    if elapsed >= 5_000 {
        2
    } else if elapsed >= 1_000 {
        1
    } else {
        0
    }
}
#41
SOLE CROWN #1 <10 CYC
phoenix_decay_q15
domain: ayecast-x86_64 | id: e38128c8e801
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.
Specialized Multi-Pin Stage `(u64,u64)->u16` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u64,u64)->u16
64-vec BLAKE3: 8dda8119f2d6
C64 RAM: 87/16384 (348 B src)
1300123/200000 cyc/op
14109/8000 ns/op | 8000000/14109 ops/us
95 B .text (27 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (348 B)
pub const fn phoenix_decay_q15(t_sec: u64, tau_sec: u64) -> u16 { if tau_sec == 0 { return 32_768; } let tau = (if tau_sec > 1_000_000 { 1_000_000 } else { tau_sec }) as u128; let t = (if t_sec > 10_000_000 { 10_000_000 } else { t_sec }) as u128; let num = 4 * tau * tau * 32_768; let den = 4 * tau * tau + 4 * tau * t + t * t; (num / den) as u16 }
#443
SOLE CROWN #1
unpack_5_trits_base243
domain: ayecast-x86_64 | id: 07eff900be76
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Balanced Ternary & b158 Quantization
Packing and unpacking balanced ternary (-1, 0, +1) activation lanes into dense 64-bit registers for C64-constrained inference pipelines.
Specialized Multi-Pin Stage `(u8)->[i8;5]` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u8)->[i8;5]
64-vec BLAKE3: 862195839af1
C64 RAM: 71/16384 (284 B src)
2303721/200000 cyc/op
624979/200000 ns/op | 200000000/624979 ops/us
147 B .text (48 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (284 B)
pub const fn unpack_5_trits_base243(byte: u8) -> [i8; 5] {
    let mut v = if byte >= 243 { 242 } else { byte };
    let mut out = [0i8; 5];
    let mut i = 0;
    while i < 5 {
        let rem = v % 3;
        out[i] = (rem as i8) - 1;
        v /= 3;
        i += 1;
    }
    out
}
#798
SOLE CROWN #1
step_babbage_cubic_8x_i32
domain: ayecast-x86_64 | id: 6d1c05f66367
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.
Specialized Multi-Pin Stage `(i32,i32,i32,i32)->[i32;8]` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(i32,i32,i32,i32)->[i32;8]
64-vec BLAKE3: 7ecac38e7957
C64 RAM: 967/65536 (967 B src)
394233/25000 cyc/op
427801/100000 ns/op | 100000000/427801 ops/us
270 B .text (80 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (967 B)
pub const fn step_babbage_cubic_8x_i32(p0: i32, p1: i32, p2: i32, p3: i32) -> [i32; 8] {
    let x0 = p0 as i64;
    let x1 = p1 as i64;
    let x2 = p2 as i64;
    let x3 = p3 as i64;

    // Catmull-Rom polynomial coefficients scaled by 2 * 512 = 1024 (t = k/8, k=0..7)
    let c0 = 2 * x1;
    let c1 = x2 - x0;
    let c2 = 2 * x0 - 5 * x1 + 4 * x2 - x3;
    let c3 = -x0 + 3 * x1 - 3 * x2 + x3;

    // Evaluate at k = 0, 1, 2, 3 to seed Babbage forward differences (d1, d2, d3)
    let f0 = c0 * 512;
    let f1 = c0 * 512 + c1 * 64 + c2 * 8 + c3;
    let f2 = c0 * 512 + c1 * 128 + c2 * 32 + c3 * 8;
    let f3 = c0 * 512 + c1 * 192 + c2 * 72 + c3 * 27;

    let mut y = f0;
    let mut d1 = f1 - f0;
    let mut d2 = (f2 - f1) - d1;
    let d3 = f3 - 3 * f2 + 3 * f1 - f0;

    let mut out = [0i32; 8];
    let mut k = 0;
    while k < 8 {
        out[k] = (y >> 10) as i32;
        y += d1;
        d1 += d2;
        d2 += d3;
        k += 1;
    }
    out
}
#948
SOLE CROWN #1
pack_5_trits_base243
domain: ayecast-x86_64 | id: a32f83726652
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Balanced Ternary & b158 Quantization
Packing and unpacking balanced ternary (-1, 0, +1) activation lanes into dense 64-bit registers for C64-constrained inference pipelines.
Specialized Multi-Pin Stage `([i8;5])->u8` — wire matching input pins via `snap_dag` or `snap_pipeline`.
([i8;5])->u8
64-vec BLAKE3: 8a9c47d14f73
C64 RAM: 379/65536 (379 B src)
3767491/200000 cyc/op
2044161/400000 ns/op | 400000000/2044161 ops/us
156 B .text (50 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (379 B)
pub const fn pack_5_trits_base243(trits: [i8; 5]) -> u8 {
    let mut acc: u16 = 0;
    let mut pow3: u16 = 1;
    let mut i = 0;
    while i < 5 {
        let digit: u16 = if trits[i] < 0 {
            0
        } else if trits[i] > 0 {
            2
        } else {
            1
        };
        acc += digit * pow3;
        pow3 *= 3;
        i += 1;
    }
    acc as u8
}
#1548
CROWN #1 of 2
compute_window_energy_i16
domain: ayecast-x86_64 | id: 47793527a516
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.
Specialized Multi-Pin Stage `(&[i16])->u64` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(&[i16])->u64
64-vec BLAKE3: f158fb26515c
C64 RAM: 247/65536 (247 B src)
453173/20000 cyc/op
1229421/200000 ns/op | 200000000/1229421 ops/us
130 B .text (36 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (247 B)
pub fn compute_window_energy_i16(window: &[i16]) -> u64 {
    let mut sum: u64 = 0;
    let mut i = 0;
    while i < window.len() {
        let s = window[i] as i64;
        sum = sum.saturating_add((s * s) as u64);
        i += 1;
    }
    sum
}
#1553
PEER of 2
compute_window_energy_i16
domain: ayecast-x86_64 | id: b92f040b68b0
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.
Specialized Multi-Pin Stage `(&[i16])->u64` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(&[i16])->u64
64-vec BLAKE3: f158fb26515c
C64 RAM: 203/65536 (203 B src)
4546649/200000 cyc/op
616727/100000 ns/op | 100000000/616727 ops/us
130 B .text (36 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (203 B)
pub fn compute_window_energy_i16(window: &[i16]) -> u64 { let mut sum: u64 = 0; let mut i = 0; while i < window.len() { let s = window[i] as i64; sum = sum.saturating_add((s * s) as u64); i += 1; } sum }
#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
}
#1684
CROWN #1 of 2
is_dropped_legacy_web_feature
domain: ayecast-x86_64 | id: c63d21901bd3
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.
Specialized Multi-Pin Stage `(&str)->bool` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(&str)->bool
64-vec BLAKE3: cf029ab232ff
C64 RAM: 27/4096 (432 B src)
8644891/200000 cyc/op
1172609/100000 ns/op | 100000000/1172609 ops/us
1311 B .text (331 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (432 B)
pub fn is_dropped_legacy_web_feature(feature_or_tag: &str) -> bool {
    let lower = feature_or_tag.trim().to_ascii_lowercase();
    matches!(
        lower.as_str(),
        "frameset"
            | "frame"
            | "applet"
            | "marquee"
            | "blink"
            | "keygen"
            | "document.write"
            | "xpath"
            | "xslt"
            | "websql"
            | "quirks-mode"
    )
}
#1715
CROWN #1 of 2
crc32_ieee
domain: ayecast-x86_64 | id: d9ce35ad8bc3
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Cryptographic Mixing, Checksums & Wire Integrity
Fast wire-speed packet checksum verification, case-folded label hashing, and frame integrity sealing on network ingress paths.
Slice Ingress / Scanner Stage `(&[u8])->u32` — digests raw byte buffers into scalar tokens or checksums.
(&[u8])->u32
64-vec BLAKE3: cc409111601b
C64 RAM: 187/32768 (374 B src)
26681929/200000 cyc/op
14476559/400000 ns/op | 400000000/14476559 ops/us
178 B .text (49 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (374 B)
pub const fn crc32_ieee(data: &[u8]) -> u32 {
    let mut crc: u32 = 0xFFFF_FFFF;
    let mut i = 0;
    while i < data.len() {
        crc ^= data[i] as u32;
        let mut bit = 0;
        while bit < 8 {
            let mask = (crc & 1).wrapping_neg();
            crc = (crc >> 1) ^ (0xEDB8_8320 & mask);
            bit += 1;
        }
        i += 1;
    }
    !crc
}
#2035
PEER of 3
isqrt_u64
domain: ayecast-x86_64 | id: 701c3bcfc01c
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Exact Integer Number Theory & Transcendentals
Hardware-verified modular arithmetic, integer roots, and combinatorial invariants for exact rational math engines and cryptographic primitives.
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: 51/16384 (204 B src)
288519/625 cyc/op
10018371/80000 ns/op | 80000000/10018371 ops/us
115 B .text (34 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (204 B)
pub const fn isqrt_u64(n: u64) -> u64 {
    if n < 2 {
        return n;
    }
    let mut x = n;
    let mut y = (x + 1) >> 1;
    while y < x {
        x = y;
        y = (x + n / x) >> 1;
    }
    x
}
#2036
PEER of 8
gcd_u64
domain: ayecast-x86_64 | id: 6ac4c0cf31db
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Exact Integer Number Theory & Transcendentals
Hardware-verified modular arithmetic, integer roots, and combinatorial invariants for exact rational math engines and cryptographic primitives.
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: 41/16384 (164 B src)
193134903/400000 cyc/op
52398841/400000 ns/op | 400000000/52398841 ops/us
68 B .text (23 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (164 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 }
}
Page 1 of 1 (23 total capsules)