Press enter or click to view image in full size

SLV Adds SHA-256 Optimization Patch (kagren Patch) for Solana Validator PoH — 10–20% Speed Improvement

--

gm!

SLV now supports an optimization patch (known as the kagren patch) that accelerates the SHA-256 computation used by Solana validator PoH (Proof of History).

Following real-world validation on the Epics DAO validator, the patch has been integrated into SLV in a form that applies to both Solana validators and Solana RPC nodes, and can be applied by any SLV user through nothing more than a conversation with an AI agent.

On AMD Zen3 or newer CPUs equipped with SHA-NI instructions, a 10–20% improvement in the PoH speed check measured at startup is expected. This performance gain translates directly into additional processing headroom during leader slots on Solana validators.

SLV Website:

https://slv.dev/en

SLV GitHub:

https://github.com/validatorsDAO/slv

What Is the kagren Patch? — Precise Optimization of the Hottest Path in Solana Validators

Solana’s consensus is built on a continuous SHA-256 hash chain known as Proof of History (PoH). The process of taking the previous hash (32 bytes) as input to generate the next hash is repeated hundreds of thousands of times within a single slot (approximately 400 ms). Among all code paths in a Solana validator, this PoH SHA-256 computation is the most frequently executed and is the dominant consumer of CPU time.

The so-called “kagren patch” is a targeted effort to optimize this hottest path. Its original author, kagren, has forked the sha256-hasher from solana-sdk and provides a SHA-NI implementation specialized for PoH’s input condition of 32 bytes in a single block.

This patch is released under the Creative Commons CC0 1.0 Universal License, allowing anyone to freely use, modify, and redistribute it. We extend our sincere respect to kagren for this contribution, released openly to the Solana ecosystem.

solana-sha256-hasher-optimized (kagren):

https://github.com/kagren/solana-sha256-hasher-optimized

SHA-NI Instructions and Deterministic Optimization for 32-Byte, Single-Block Input

SHA-256 is an algorithm that processes data in 64-byte (512-bit) blocks. When hashing a 32-byte input, the remaining 32 bytes are filled with specification-defined padding — a leading 0x80 byte, zero padding, and a trailing bit sequence representing the input length.

The key observation is this: when hashing is always performed on 32 bytes in a single block, as in PoH, this padding is entirely deterministic. The kagren patch unfolds these deterministic portions ahead of time along the SHA-NI computation path, stripping out the branches, loops, and loads that were present in the general-purpose implementation. As a result, for PoH’s specific input condition of 32 bytes and a single block, it extracts the maximum throughput from SHA-NI.

For inputs other than 32 bytes, or when spanning multiple blocks, the original general-purpose implementation continues to be used. On-chain SHA-256 computation (hash calls inside programs running on the SBF) is also left entirely unchanged.

10–20% Improvement in PoH Speed Check — Direct Impact on Leader Slot Processing Headroom

On AMD Zen3 or newer CPUs, the PoH speed check value measured at Solana validator startup has been reported by the original author to improve by 10–20% after applying this patch. We observed a similar level of improvement in real-world validation on the Epics DAO validator.

The meaning of this improvement goes beyond a mere benchmark number. PoH computational headroom translates directly into the processing headroom a Solana validator has during its leader slots. Transaction ingestion, Compute Unit accumulation, block production — within the limited time available in a leader slot, reducing the CPU time consumed by PoH computation increases the resources available for every other task.

This is a quiet but reliable improvement that lifts the key performance indicators of a validator: vote latency, skip rate, and Compute Units per block.

No Impact on Consensus — Fully Compatible Fallback Design

SHA-256 computations under the kagren patch produce results identical to those of the standard implementation. The execution path branches based on the input condition: 32-byte, single-block inputs take the optimized route, while everything else falls back to the standard implementation. On-chain SHA-256 computation remains entirely unchanged.

There is no structural risk of consensus-level issues. Before deploying patched binaries, SLV runs a verification step to confirm result parity with the standard implementation, and only then proceeds with the switch-over.

Target CPUs and Prerequisites

This patch only delivers its benefit on CPUs equipped with the SHA-NI instruction set. Specifically, this means AMD Zen3 or later architectures — EPYC 7003 / 9004 / 9005 series, Ryzen 5000 series and later, Threadripper 5000 / 7000 series, and similar processors.

Most of the configurations used in Epics DAO validator operations and across the ERPC platform meet this condition. On older-generation CPUs without SHA-NI instructions, SLV skips the patch application and continues operation on the standard implementation.

Real-World Validation on the Epics DAO Validator — Another Building Block Behind Our World #3 Ranking

Press enter or click to view image in full size

The Epics DAO validator, which we operate as the source for ERPC’s SWQoS endpoints and Epic Shreds feed, has reached world rank #3 overall (score 99.93) among all Solana validators in the Shinobi Performance Pool. This result reflects the accumulation of multiple improvements: hardware selection, kernel parameter optimization, network stack tuning, IRQ affinity adjustment, and DoubleZero integration.

The kagren patch integration is another addition to this accumulation. After real-world validation on the Epics DAO validator confirmed both its effectiveness and stability in production, we incorporated it into SLV as a built-in skill.

Validator and RPC Dual Support in SLV — Automatic Client Detection and Remote Build & Deploy

With this release, both Solana validators and Solana RPC nodes are covered as targets for patch application in SLV.

SLV automatically detects the client type running on the target node (Agave, Jito-Agave) and clones the appropriate Solana source tree into a remote build environment. The entire process — applying the patch, rebuilding with optimization flags, backing up the existing binary, and deploying the patched binary — runs end-to-end under SLV’s control.

Combined with the AI Agent — Entirely Through Natural Language

Press enter or click to view image in full size

Like the rest of SLV’s functionality, kagren patch application is exposed through MCP (Model Context Protocol). By launching the AI Console and simply telling the AI agent something like “Apply the SHA-256 optimization patch to this validator”, the entire flow — node identification, build, and deploy — is carried out by the agent.

Direct CLI execution is also supported, so the same operation can be incorporated into scripted automation flows.

Try It Right Now with SLV AI Tokens

Kagren patch application is also available as part of SLV’s AI agent functionality. By using SLV AI tokens, the entire application work can be completed through natural language dialogue with the AI agent.

As a launch promotion, we are distributing 100,000 tokens free of charge with a €5 authorization. Connections using ChatGPT and Claude API tokens are also supported.

ERPC SLV AI Plans:

Combined with the ERPC Platform

All Solana validators and Solana RPC nodes running on the ERPC platform are built on AMD Zen4 or newer CPUs — configurations that benefit from the kagren patch. By deploying an environment built with SLV onto the ERPC platform, users get all of the following from day one: high-speed snapshot downloads, zero-distance communication with Solana validators, Solana-specific tuned configurations, and PoH acceleration via the kagren patch.

ERPC Website:

Five Consecutive Years of WBSO Approval — AS200261 Solana-Dedicated Datacenter

We have received approval for five consecutive years since 2022 under WBSO, the research and development support program of the Dutch government. We are building a Solana-dedicated datacenter under our own ASN (AS200261), assigned by RIPE NCC. With hardware standardized on AMD EPYC 5th Gen, AMD Threadripper PRO 5th Gen (9975WX and above), and NVMe Gen 5 — combined with optimal network path design — this facility delivers top-tier quality. The opening is scheduled for this month.

Acknowledgment to kagren

This integration into SLV would not have been possible without the work that kagren made public. We once again extend our deep respect and gratitude for this effort, released under CC0 as a contribution to the Solana ecosystem.

Epics DAO Website:

Validators DAO Official Discord: