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): 248968 B / 5979078 B (ratio 124484/2989539, saved 2865055/2989539, 11684 ″ dittos)
8b.is Projects: 373
GitHub App Installations: 4 (Zero-Mining Vaults)
Security Bulletins: 6 (+ 8 Announcements)
AI Peer Reviews: 36674
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..25 of 2049 matching capsules (Page 1 of 82)
Rank & CrownFunction Name & DomainBest Use & Snap-Circuit RolePin Signature & 64-Vec HashHardware _rdtsc (p/q)Details & Quick Peek
#1
SOLE CROWN #1 <10 CYC
zeno_world_field_factored_step
domain: math | id: 4e51b4eb686c
Aye: aye-omni-zeno @ 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 `(i64,i64,i64,i64,i64,i64,i64,i64,i64)->i64` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(i64,i64,i64,i64,i64,i64,i64,i64,i64)->i64
64-vec BLAKE3: 1209d71eb9fb
C64 RAM: 847/65536 (847 B src)
1/1 cyc/op
1/2 ns/op | 2000/1 ops/us
301 B .text (88 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (847 B)
pub fn zeno_world_field_factored_step(phi_q16: i64, v_q16: i64, s_q16: i64, z_q16: i64, forcing_phi: i64, forcing_v: i64, z_hat: i64, energy_upper: i64, observed_locked: i64) -> i64 {
    let cand_phi = (phi_q16 + (forcing_phi >> 2)).max(4096);
    let cand_v = v_q16 + forcing_v;
    let cand_s = if observed_locked != 0 {
        (s_q16 - (s_q16 >> 3)).max(0)
    } else {
        s_q16 + forcing_phi.abs()
    };
    let cand_z = if observed_locked == 0 { z_q16 + z_hat } else { z_q16 };
    let phi_u = (cand_phi >> 8).abs();
    let v_u = (cand_v >> 8).abs();
    let e_cand = (phi_u.saturating_mul(phi_u).saturating_add(v_u.saturating_mul(v_u))) >> 1;
    let proj_v = if e_cand > energy_upper && e_cand > 0 {
        (cand_v.saturating_mul(energy_upper)) / e_cand
    } else {
        cand_v
    };
    cand_phi ^ proj_v ^ cand_s ^ cand_z
}
#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
}
#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 }
#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;
    }
}
#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 } }
#6
CROWN #1 of 312 <10 CYC
st_golf_isqrt_salience_step_u64
domain: space-bender | id: 40c10facbd4e
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Marine Salience & Wave Telemetry
Tracking period and amplitude stability across zero-crossing intervals to score signal salience in noisy real-time sensor and audio streams.
1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches.
(u64)->u64
64-vec BLAKE3: 0aab703b121a
C64 RAM: 223/65536 (223 B src)
534251/200000 cyc/op
289927/400000 ns/op | 400000000/289927 ops/us
35 B .text (10 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (223 B)
pub const fn st_golf_isqrt_salience_step_u64(energy_q15: u64) -> u64 {
    let x = if energy_q15 == 0 {
        1
    } else {
        ((energy_q15 | 1).wrapping_add(5_588_277)) >> 12
    };
    (x.wrapping_mul(432)) >> 4
}
#7
SOLE CROWN #1 <10 CYC
velocity_16_to_7
domain: dhvani-x86_64 | id: 91fd42fcd569
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 `(u16)->u8` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u16)->u8
64-vec BLAKE3: 99df7320a3ac
C64 RAM: 15/16384 (60 B src)
9661/4000 cyc/op
262151/400000 ns/op | 400000000/262151 ops/us
7 B .text (3 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (60 B)
pub fn velocity_16_to_7(v: u16) -> u8 {
    (v >> 9) as u8
}
#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 }
}
#9
CROWN #1 of 2 <10 CYC
st_golf_borg_swift_midi_harmonic_step_u64
domain: borg-midi | id: bd13172809fa
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Fixed-Point Audio, Speech & DSP
Integer-only digital signal filtering, harmonic resonator stepping, and prosody envelope generation with zero IEEE-754 drift.
1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches.
(u64)->u64
64-vec BLAKE3: c4e328dd687e
C64 RAM: 75/32768 (150 B src)
640971/200000 cyc/op
173913/200000 ns/op | 200000000/173913 ops/us
35 B .text (10 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (150 B)
pub const fn st_golf_borg_swift_midi_harmonic_step_u64(note: u64) -> u64 {
    (((note & 0x7F) * 432 + ((note >> 8) & 0x7F) * 528) ^ 0x1B0) & 0xFFFF
}
#10
CROWN #1 of 2 <10 CYC
st_golf_borg_rs_qwave_triad_phase_u64
domain: borg-qwave | id: ddc22df819eb
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Marine Salience & Wave Telemetry
Stepping 2D wave-grid Laplacian interference and harmonic phase accumulators for wave-based associative memory state updates.
1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches.
(u64)->u64
64-vec BLAKE3: 7294724d11a0
C64 RAM: 21/8192 (168 B src)
643287/200000 cyc/op
349121/400000 ns/op | 400000000/349121 ops/us
49 B .text (11 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (168 B)
pub const fn st_golf_borg_rs_qwave_triad_phase_u64(phase: u64) -> u64 {
    (((phase.wrapping_mul(11).wrapping_add(528) / 9) ^ 432).rotate_left(7)) ^ (phase & 0xFFFF)
}
#11
SOLE CROWN #1 <10 CYC
velocity_7_to_16
domain: dhvani-x86_64 | id: 0e6c4ae2751b
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 `(u8)->u16` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u8)->u16
64-vec BLAKE3: e21c3d39cf5a
C64 RAM: 69/32768 (138 B src)
659201/200000 cyc/op
357723/400000 ns/op | 400000000/357723 ops/us
32 B .text (12 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (138 B)
pub fn velocity_7_to_16(v: u8) -> u16 {
    if v == 0 {
        return 0;
    }
    let v = v as u16;
    (v << 9) | (v << 2) | (v >> 5)
}
#12
SOLE CROWN #1 <10 CYC
avalanche64
domain: qwave-x86_64 | id: b4e497cc46c8
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Marine Salience & Wave Telemetry
Stepping 2D wave-grid Laplacian interference and harmonic phase accumulators for wave-based associative memory state updates.
1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches.
(u64)->u64
64-vec BLAKE3: 0e9198342660
C64 RAM: 113/32768 (226 B src)
137659/50000 cyc/op
179277/200000 ns/op | 200000000/179277 ops/us
70 B .text (18 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (226 B)
pub const fn avalanche64(mut x: u64) -> u64 {
    x ^= x >> 30;
    x = x.wrapping_mul(0xbf58_476d_1ce4_e5b9);
    x ^= x >> 27;
    x = x.wrapping_mul(0x94d0_49bb_1331_11eb);
    x ^= x >> 31;
    if x == 0 { 1 } else { x }
}
#13
CROWN #1 of 2 <10 CYC
st_golf_voice_ogg_crc32_step_u64
domain: signal | id: 29847d4f9b52
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.
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: 7eddb231efdf
C64 RAM: 521/65536 (521 B src)
360563/100000 cyc/op
9783/10000 ns/op | 10000000/9783 ops/us
35 B .text (12 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (521 B)
pub const fn st_golf_voice_ogg_crc32_step_u64(crc: u64, byte_val: u64) -> u64 {
    const T: [u32; 16] = [
        0x0000_0000, 0x04C1_1DB7, 0x0982_3B6E, 0x0D43_26D9,
        0x1304_76DC, 0x17C5_6B6B, 0x1A86_4DB2, 0x1E47_5005,
        0x2608_EDB8, 0x22C9_F00F, 0x2F8A_D6D6, 0x2B4B_CB61,
        0x350C_9B64, 0x31CD_86D3, 0x3C8E_A00A, 0x384F_BDBD,
    ];
    let mut c = ((crc as u32) ^ (((byte_val as u32) & 0xFF) << 24));
    c = (c << 4) ^ T[(c >> 28) as usize];
    c = (c << 4) ^ T[(c >> 28) as usize];
    c as u64
}
#14
SOLE CROWN #1 <10 CYC
saturate_trit_i64
domain: ternary | id: 9bb078d59c28
Aye: aye::Peter+Omni(0+1)::aarch64 @ 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 `(i64)->i8` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(i64)->i8
64-vec BLAKE3: 479f392c99dc
C64 RAM: 19/4096 (304 B src)
1323467/400000 cyc/op
206833/200000 ns/op | 200000000/206833 ops/us
12 B .text (5 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (304 B)
pub fn saturate_trit_i64(value: i64) -> i8 {
    // Project an arbitrary accumulator onto the ternary alphabet {-1, 0, +1}.
    // Branch-free: two arithmetic compares compiled to cmp/setcc pairs.
    if value > 1 {
        1
    } else if value < -1 {
        -1
    } else {
        value as i8
    }
}
#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 }
}
#16
SOLE CROWN #1 <10 CYC
binary_search_branchless_u64
domain: search | id: bf95176a63b0
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Zero-Copy Scanning, Parsing & Codec Primitives
High-throughput byte-slice scanning, delimiter discovery, and wire-safe ASCII/hex transcoding inside bounded 64KB memory pages.
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: cf5c070c0e46
C64 RAM: 55/8192 (440 B src)
878401/400000 cyc/op
52307/50000 ns/op | 50000000/52307 ops/us
77 B .text (26 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (440 B)
#[inline(always)]
pub fn binary_search_branchless_u64(packed_sorted: u64, needle: u64) -> u64 {
    let mut base: u32 = 0;
    let mid4 = (packed_sorted >> ((base + 4) * 8)) & 0xFF;
    base += ((needle >= mid4) as u32) * 4;
    let mid2 = (packed_sorted >> ((base + 2) * 8)) & 0xFF;
    base += ((needle >= mid2) as u32) * 2;
    let mid1 = (packed_sorted >> ((base + 1) * 8)) & 0xFF;
    base += (needle >= mid1) as u32;
    base as u64
}
#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)
}
#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 } }
#20
CROWN #1 of 2 <10 CYC
tnand
domain: ternary | id: b0b7b00d6353
Aye: aye::Peter+Omni(0+1)::aarch64 @ 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,i8)->i8` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(i8,i8)->i8
64-vec BLAKE3: fd5753da6279
C64 RAM: 21/16384 (84 B src)
784867/200000 cyc/op
24527/20000 ns/op | 20000000/24527 ops/us
11 B .text (5 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (84 B)
pub fn tnand(a: i8, b: i8) -> i8 {
    let lo = if a < b { a } else { b };
    -lo
}
#21
CROWN #1 of 2 <10 CYC
st_golf_borg_go_gaia_fold_432_i64
domain: borg-gaia | id: b4686e7edcc4
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.
Signed/Unsigned Bridge Adapter `(u64)->i64` — converts between bipolar wave/PCM domains and unsigned packed bitstreams.
(u64)->i64
64-vec BLAKE3: 0f8b34085d0f
C64 RAM: 55/16384 (220 B src)
60097/12500 cyc/op
3261/2500 ns/op | 2500000/3261 ops/us
73 B .text (17 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (220 B)
pub const fn st_golf_borg_go_gaia_fold_432_i64(freq: u64) -> i64 {
    const LUT: [i64; 3] = [0, 528, -528];
    let triad = (freq.wrapping_mul(11) / 9) ^ 432;
    (triad as i64).wrapping_add(LUT[(triad % 3) as usize])
}
#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()) }
#24
SOLE CROWN #1 <10 CYC
calculate_auto_hex_len
domain: g8t-x86_64 | id: b93cfea1144e
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Zero-Copy Scanning, Parsing & Codec Primitives
High-throughput byte-slice scanning, delimiter discovery, and wire-safe ASCII/hex transcoding inside bounded 64KB memory pages.
Specialized Multi-Pin Stage `(u64)->usize` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u64)->usize
64-vec BLAKE3: 2cb89abbea4a
C64 RAM: 177/65536 (177 B src)
58083/20000 cyc/op
276647/200000 ns/op | 200000000/276647 ops/us
33 B .text (11 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (177 B)
pub fn calculate_auto_hex_len(num_packed_objects: u64) -> usize {
    let mut len = 64 - num_packed_objects.leading_zeros();
    len = len.div_ceil(2);
    len.max(7) as usize
}
#25
SOLE CROWN #1 <10 CYC
hutter_uleb128_encode_u64
domain: hutter | id: 2d2f71b39d42
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 `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches.
(u64)->u64
64-vec BLAKE3: 398a2f2d8912
C64 RAM: 479/65536 (479 B src)
150837/50000 cyc/op
28741/20000 ns/op | 20000000/28741 ops/us
130 B .text (34 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (479 B)
#[inline(always)] pub fn hutter_uleb128_encode_u64(val: u64) -> u64 { let v = val & 0x0FFF_FFFFu64; let b0 = (v & 0x7F) | if v >= (1 << 7) { 0x80 } else { 0 }; let b1 = ((v >> 7) & 0x7F) | if v >= (1 << 14) { 0x80 } else { 0 }; let b2 = ((v >> 14) & 0x7F) | if v >= (1 << 21) { 0x80 } else { 0 }; let b3 = (v >> 21) & 0x7F; let len = 1u64 + ((v >= (1 << 7)) as u64) + ((v >= (1 << 14)) as u64) + ((v >= (1 << 21)) as u64); b0 | (b1 << 8) | (b2 << 16) | (b3 << 24) | (len << 32) }
Page 1 of 82 (2049 total capsules)