Been looking into some of @Starknet latest developments and SNIP-36 caught my attention. It's called In Protocol Proof Verification and the latest v0.14.4 upgrade makes it even more interesting. But first, what exactly does SNIP-36 do? Think about applications that need to perform heavy computations. Doing all that work directly on chain can be expensive and resource intensive. SNIP-36 introduces another approach. Applications can execute suitable logic off chain, generate a STARK proof of that execution and submit the proof to Starknet for verification. Here's how the process works: - The application executes its logic off chain against a specific Starknet state. - The S Two prover generates a proof showing that the execution was valid. - The application submits the proof along with data called proof_facts. - Starknet consensus verifies the proof, and the application's contract can use the verified result to perform the required state changes. In simple terms, the computation happens off chain, while its correctness can still be verified on Starknet. Now, here's what makes the latest upgrade interesting. With Starknet v0.14.4, SNIP-36 expands beyond small virtual transactions to support proving much larger, block sized computations. Under the specified conditions, a single proven transaction can contain up to 1.1 billion L2 gas worth of computation. That means applications can potentially handle workloads that would be too large for a regular transaction, by proving the execution instead of paying for it as normal on chain execution. So, why does this matter? 1. ZKThreads and application scaling Applications can move more of their execution off chain and bring verified results back to Starknet. This opens up possibilities for application specific scaling through ZKThreads. 2. Privacy focused applications SNIP-36 can also support applications that use private inputs while revealing only the necessary public results. The current implementation offers computational privacy, but it should not be confused with full mathematical zero knowledge privacy guarantees. 3. More flexibility for developers Developers get more room to build applications that need complex computations without forcing every part of that workload through regular on chain execution. One thing I find interesting about Starknet is that it's not just focused on processing more transactions. It's also making it easier for apps to handle complex computations without pushing all the workload on chain. That's where SNIP-36 gets interesting. More computation with verifiable results means more possibilities for builders on Starknet. Still early, but definitely something worth keeping an eye on.