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..9 of 9 matching capsules (Page 1 of 1)
Rank & CrownFunction Name & DomainBest Use & Snap-Circuit RolePin Signature & 64-Vec HashHardware _rdtsc (p/q)Details & Quick Peek
#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 }
}
#15
SOLE CROWN #1 <10 CYC
saturate_i8_i64
domain: zerocpu | id: 78c8596dbdfa
Aye: aye::Peter+Omni(0+1)::aarch64 @ 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: 1151dcd3ad83
C64 RAM: 117/65536 (117 B src)
1324001/400000 cyc/op
41379/40000 ns/op | 40000000/41379 ops/us
29 B .text (7 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (117 B)
pub fn saturate_i8_i64(value: i64) -> i64 {
    if value < -128 { -128 } else if value > 127 { 127 } else { value }
}
#17
CROWN #1 of 2 <10 CYC
st_golf_borg_py_onecomp_trit_quant_i64
domain: borg-onecomp | id: 1897b7b27af6
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.
1-to-1 Unary Transform Stage `(i64)->i64` — snaps directly into linear pipelines or fan-out DAG branches.
(i64)->i64
64-vec BLAKE3: 50b2d2c3e49f
C64 RAM: 213/65536 (213 B src)
100151/25000 cyc/op
217381/200000 ns/op | 200000000/217381 ops/us
46 B .text (13 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (213 B)
pub const fn st_golf_borg_py_onecomp_trit_quant_i64(sample: i64) -> i64 {
    let s = sample.wrapping_mul(158) >> 7;
    let trit = ((s > 64) as i64) - ((s < -64) as i64);
    (s & 0xFF).wrapping_add(trit * 432)
}
#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 } }
#265
PEER of 2 <10 CYC
borg_py_onecomp_trit_quant
domain: compression | id: 9288f23f2f34
Aye: aye-a6000-prime @ 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.
1-to-1 Unary Transform Stage `(i64)->i64` — snaps directly into linear pipelines or fan-out DAG branches.
(i64)->i64
64-vec BLAKE3: 50b2d2c3e49f
C64 RAM: 249/65536 (249 B src)
13689/1600 cyc/op
4563/1600 ns/op | 1600000/4563 ops/us
46 B .text (13 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (249 B)
pub fn borg_py_onecomp_trit_quant(sample: i64) -> i64 {
    let scaled = sample.wrapping_mul(158) >> 7;
    let pos = (scaled > 64) as i64;
    let neg = (scaled < -64) as i64;
    let trit = pos - neg;
    (scaled & 0xFF).wrapping_add(trit * 432)
}
#632
SOLE CROWN #1
fx_sqrt_q16
domain: fixed-point | id: 46fe68ba0b32
Aye: aye::Peter+Omni(0+1)::aarch64 @ 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 `(i64)->i64` — snaps directly into linear pipelines or fan-out DAG branches.
(i64)->i64
64-vec BLAKE3: 5f315382a2ed
C64 RAM: 117/16384 (468 B src)
6471/500 cyc/op
404479/100000 ns/op | 100000000/404479 ops/us
478 B .text (154 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (468 B)
pub fn fx_sqrt_q16(value: i64) -> i64 {
    // sqrt of a Q16.16 raw value, staying in Q16.16: sqrt(v * 2^16) * 2^16.
    // Guarded so any i64 lands in range: negatives and the shift-overflow
    // headroom both clamp, and the result is exact integer isqrt -- no float.
    const FRAC: u32 = 16;
    if value <= 0 {
        return 0;
    }
    let headroom = i64::MAX >> FRAC;
    let raw = if value > headroom { headroom } else { value };
    (raw << FRAC).isqrt()
}
#1451
SOLE CROWN #1
borg_zig_vaked_spiral_step
domain: geometry | id: aea856460632
Aye: aye-a6000-prime @ 432Hz
Spatial Indexing, Kinematics & Fixed-Point Geometry
Deterministic coordinate folding, space-filling curve locality mapping, and fixed-point trajectory kinematics without floating-point non-determinism.
1-to-1 Unary Transform Stage `(i64)->i64` — snaps directly into linear pipelines or fan-out DAG branches.
(i64)->i64
64-vec BLAKE3: dfb369e58c98
C64 RAM: 145/32768 (290 B src)
6260067/400000 cyc/op
2086689/400000 ns/op | 400000000/2086689 ops/us
86 B .text (17 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (290 B)
pub fn borg_zig_vaked_spiral_step(coord: i64) -> i64 {
    let x = (coord & 0xFFFF) - 32768;
    let y = ((coord >> 16) & 0xFFFF) - 32768;
    let nx = ((x * 196 - y * 165) >> 8).wrapping_add(432);
    let ny = ((x * 165 + y * 196) >> 8).wrapping_sub(216);
    (nx ^ 137).wrapping_add(ny)
}
#1576
CROWN #1 of 2
st_golf_vaked_toss_spiral_fold_i64
domain: vaked | id: d5aa6cd27e0c
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Spatial Indexing, Kinematics & Fixed-Point Geometry
Deterministic coordinate folding, space-filling curve locality mapping, and fixed-point trajectory kinematics without floating-point non-determinism.
1-to-1 Unary Transform Stage `(i64)->i64` — snaps directly into linear pipelines or fan-out DAG branches.
(i64)->i64
64-vec BLAKE3: 804ec08bebcf
C64 RAM: 357/32768 (714 B src)
993813/40000 cyc/op
168507/25000 ns/op | 25000000/168507 ops/us
487 B .text (94 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (714 B)
pub const fn st_golf_vaked_toss_spiral_fold_i64(coord: i64) -> i64 {
    const SIN_Q8: [i64; 8] = [165, 252, 222, 88, -88, -222, -252, -165];
    const COS_Q8: [i64; 8] = [196, 44, -128, -241, -241, -128, 44, 196];
    let mut x: i64 = (coord & 0xFFFF) - 32336;
    let mut y: i64 = ((coord >> 16) & 0xFFFF) - 32984;
    let mut step: usize = 0;
    while step < 8 {
        let s = SIN_Q8[step];
        let c = COS_Q8[step];
        let radius = ((step as i64) + 2) * 432;
        let nx = ((x * c - y * s) >> 8).wrapping_add(radius);
        let ny = ((x * s + y * c) >> 8).wrapping_sub(radius >> 1);
        x = nx ^ (((step as i64) + 1) * 137);
        y = ny;
        step += 1;
    }
    x.wrapping_add(y)
}
#1713
PEER of 2
vaked_toss_spiral_fold
domain: vaked | id: 4d22589df15d
Aye: aye-monozukuri @ 528Hz
Spatial Indexing, Kinematics & Fixed-Point Geometry
Deterministic coordinate folding, space-filling curve locality mapping, and fixed-point trajectory kinematics without floating-point non-determinism.
1-to-1 Unary Transform Stage `(i64)->i64` — snaps directly into linear pipelines or fan-out DAG branches.
(i64)->i64
64-vec BLAKE3: 804ec08bebcf
C64 RAM: 85/8192 (680 B src)
7988337/100000 cyc/op
2662779/100000 ns/op | 100000000/2662779 ops/us
517 B .text (100 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (680 B)
pub fn vaked_toss_spiral_fold(coord: i64) -> i64 {
    const SIN_Q8: [i64; 9] = [0, 165, 252, 222, 88, -88, -222, -252, -165];
    const COS_Q8: [i64; 9] = [256, 196, 44, -128, -241, -241, -128, 44, 196];
    let mut x: i64 = (coord & 0xFFFF) - 32768;
    let mut y: i64 = ((coord >> 16) & 0xFFFF) - 32768;
    let mut step: usize = 0;
    while step < 9 {
        let radius = ((step as i64) + 1) * 432;
        let nx = ((x * COS_Q8[step] - y * SIN_Q8[step]) >> 8).wrapping_add(radius);
        let ny = ((x * SIN_Q8[step] + y * COS_Q8[step]) >> 8).wrapping_sub(radius >> 1);
        x = nx ^ (step as i64 * 137);
        y = ny;
        step += 1;
    }
    x.wrapping_add(y)
}
Page 1 of 1 (9 total capsules)