The Nameless One

Brief Introduction:
The goal of this section is to compare the proving performance of Boundless (RISC Zero / R0VM) with several representative zkVM/proving systems today — notably Plonky2 (Polygon Zero), StarkWare (STwo / Stone lineage), zkSync (Boojum / Airbender), Scroll, and Mina — across key metrics: proof generation time (proving latency), prover throughput, proof size, on-chain verification cost, hardware requirements, trust model, and developer experience.

1. Comparison Methodology — Key Metrics

Proving latency: Wall-clock time for a prover to complete a proof for a unit of work (e.g., a block, a tx-batch, or a guest execution).Prover throughput: Volume of work (ops / hashes / headers / tx) the system can handle on a given hardware configuration (ops/second, proofs/hour).Proof size: Bytes of the artifact to be submitted or stored; directly affects calldata / DA cost.On-chain verification cost: Gas cost / precompile operations required to verify the proof on the target chain.Hardware requirements & OPEX/CAPEX: CPU cores, RAM, GPU models (RTX 5090, A100…), cluster scale.Developer ergonomics & portability: Guest language, toolchain, migration friction.Trust model: SNARK vs STARK, presence of trusted setup, off-chain assumptions (attestors/bridges).
Note: Comparing systems that use different primitives (SNARK/PLONK, STARK, Plonky-style recursion, RISC-V zkVM) always involves trade-offs — there is no single “comprehensive” metric; context of the specific use-case matters.

2. Short Profile of Systems Compared

Boundless / RISC Zero (R0VM): General-purpose zkVM, runs guest code (Rust) on a RISC-V substrate; uses STARK-style pipeline with various optimizations, receipt model (journal + seal); R0VM 2.0 introduces larger memory (3GB user memory) and significant latency/throughput improvements as disclosed in publications.Plonky2 (Polygon Zero family): SNARK-style, optimized for recursion — public benchmarks indicate “recursive proof ~170 ms on MacBook Pro” for team reference tasks. Plonky2 focuses on ultra-fast recursion/aggregation, suitable for workloads requiring multi-layer proofs.StarkWare (Stone → Stwo): STARK-oriented; the recent prover “Stwo” claims large performance improvements over prior provers; STARK proofs are typically larger than SNARK but require no trusted setup and verify quickly on some platforms.zkSync (Boojum / Airbender): Boojum is the stack for Era; Airbender is a high-performance prover (claimed throughput 13 MHz on RTX 5090), aiming for real-time block-level proving with relatively low GPU configuration.Scroll: zkEVM based on PLONK/PLONK-family, focusing on EVM compatibility and coordinated proving (multi-prover, GPU+CPU hybrid).Mina: Ultra-lightweight model (22KB blockchain) based on recursive zk-SNARKs — extremely small proofs, convenient for light clients; trade-off is compute-intensive prover workflow and complex snark-daemon architecture.
3. Comparison by Metric (Detailed)

3.1 Proving Latency

Boundless / R0VM 2.0: The team reports that R0VM 2.0, with expanded memory and improvements, reduces proving time for large workloads; public roadmap and papers suggest Ethereum-block-level proofs can be shortened to a few seconds — roadmap cites figures approaching “sub-12s Ethereum proofs.”Plonky2: Public Polygon benchmark records recursion ~170 ms on MacBook Pro for a reference task — important reference for recursion-heavy pipelines. Micro-benchmark; real latency for block-level proving depends on circuit complexity and aggregation strategy.StarkWare (Stwo): Stwo is announced as “many times faster” than previous prover; StarkWare has also set proving throughput records (hashes/s) on commodity CPUs, demonstrating STARK stacks can achieve good latency/throughput when optimized.zkSync / Airbender: High prover throughput claimed (Airbender: 13 MHz on RTX 5090) aiming for real-time Ethereum proving with 8×5090 GPU cluster; block-level latency can be very low on modern hardware.
3.2 Proof Size & On-Chain Verification Cost

STARK vs SNARK vs Plonky: STARK proofs are generally larger than SNARK but verify fast and require no trusted setup; SNARK (PLONK/Plonky2) produces smaller proofs, favorable when calldata/DA cost is high. Plonky2 exploits recursion to keep on-chain verification cost low.Boundless (RISC Zero): Uses receipt model; proof size and wrapper/aggregation pipeline determine on-chain gas cost — aggregation / Merkle-root patterns are recommended to reduce on-chain verify calls.
3.3 Hardware Requirements & Operational Costs

R0VM (Boundless): Targets a distributed prover marketplace; can scale via GPU/CPU clusters; R0VM 2.0 claims ability to run on mid-size GPU clusters to achieve real-time goals.Plonky2 / Polygon: Recursion optimized on CPU & GPU; many Plonky pipelines run efficiently on commodity machines (e.g., MacBook Pro benchmarks).zkSync Airbender / Boojum: Promoted as real-time capable with 8×5090 GPUs (no massive GPU farms required).
3.4 Developer Ergonomics & Portability

Boundless / RISC Zero: Strength is “Write Rust, not circuits” — developers use Rust toolchain, easy to port existing logic; receipt model supports multiple use-cases.zkEVM stacks (Polygon zkEVM, Scroll, zkSync Era): Advantage is EVM compatibility — Solidity developers don’t need to port; however, prover plumbing and proving pipelines can be complex.Mina: Suitable for ultra-light clients, but developer model (SnarkyJS) is ecosystem-specific.
3.5 Trust Model & Security Assumptions

STARK-style (RISC Zero / StarkWare): No trusted setup required; post-quantum safe.SNARK / PLONK / Plonky2: Often require CRS / trusted parameters for some variants, but recursion/aggregation reduces verification overhead — trade-off between trust and proof size.
4. Summary: When to Choose Which — Practical Guidance

If the requirement is to prove arbitrary Rust code (quick porting, versatile) and need receipts for multi-platform integration: Boundless / RISC Zero is suitable (zkVM model, receipt pattern).If the goal is minimizing on-chain verification cost for workloads that can be efficiently circuit-encoded and require ultra-fast recursion (aggregation-heavy), Plonky2 / Polygon tooling has an advantage (micro-benchmarks show extremely fast recursion).If prioritizing extremely high throughput with resilience and no trusted setup, STARK stacks (StarkWare) and new provers (Stwo) show strong performance.If you are EVM-native and want to preserve Solidity code: zkEVM stacks (zkSync Era, Polygon zkEVM, Scroll) provide the shortest migration path; prover choice depends on latency vs cost vs decentralization trade-offs.If targeting ultra-light blockchain clients (mobile-first verification), Mina remains a reference due to extremely small proofs (22KB blockchain concept).
5. Limitations of Comparison & Short Conclusion

Limitations: Many public numbers are micro-benchmarks or measured on different workloads/configurations — cross-system comparisons can be misleading. Benchmark with your actual workload (guest code, block size, DA strategy). Teams (RISC Zero, Polygon, StarkWare, zkSync) continuously update provers; data is time-sensitive.Conclusion: No single “winner” exists; Boundless (RISC Zero) excels in generality, developer ergonomics (Rust), receipt model, and R0VM 2.0 shows major improvements in memory/throughput. However, if the goal is minimizing calldata/on-chain verify cost or leveraging EVM-native stack, Plonky2 / zkEVM / STARK stacks have situational advantages. Final decisions should be based on end-to-end benchmarking with actual workloads and total cost of ownership (prover hardware + gas + DA).
@Boundless #Boundless $ZKC

Rumour.app surgió en un momento en que el mercado de activos digitales dependía cada vez más de las narrativas — no solo de los gráficos de precios. Anunciado oficialmente por AltLayer a mediados de septiembre de 2025, Rumour.app se presenta como una “plataforma de comercio de rumores”: un lugar donde los usuarios pueden recopilar, verificar y — si lo desean — actuar (ejecutar órdenes) dentro de la misma interfaz, antes de que la información se convierta en “noticias oficiales” y los precios lo hayan reflejado completamente.

Origen de la plataforma — AltLayer y la idea de convertir “rumores” en señales

Resumen de apertura:
Holoworld se posiciona como una plataforma para crear — acuñar — comercializar agentes de IA (multimodal: video/voz/3D) con un mercado y primitivos en cadena (acuñación, procedencia, plataforma de lanzamiento), dirigido a la economía de creadores de Web3. Esto es claramente diferente de Character.ai (enfocado en experiencias conversacionales, modelo freemium/suscripción) e Inworld (integración profunda para juego/NPC con SDK/Estudio para desarrolladores). Altered State Machine (ASM) es otro eje — un protocolo/idea de Web3 destinado a la propiedad de agentes de IA a través de NFTs — esencialmente un marco conceptual para tokenizar agentes, que Holoworld está aplicando de manera productizada. A continuación se muestra una comparación basada en criterios clave, fortalezas/debilidades, escenarios adecuados e implicaciones estratégicas para Holoworld.

Resumen breve:
Boundless (desarrollado por el ecosistema RISC Zero) se centra en un zkVM de propósito general que permite probar la ejecución de programas reales (cálculo arbitrario): ejecutando código invitado escrito en Rust en un entorno de ejecución que simula RISC-V y produciendo un "recibo" que puede ser verificado de forma independiente. Este diseño difiere de los esfuerzos de "zkEVM" que apuntan a la compatibilidad con EVM o lenguajes especializados como Cairo: el objetivo de RISC Zero es un zkVM de propósito general, altamente seguro y amigable para los desarrolladores, utilizando un lenguaje popular (Rust), mientras optimiza el rendimiento a través de la hoja de ruta R0VM 2.0 y mejoras en la capa del sistema de pruebas.