Sui’s VM rewrite, the April 2026 Mainnet release record and later incident evidence. Understand caching benefits, limits and a practical regression-test matrix.
Sui’s 2026 VM rewrite changes how the network loads packages and executes Move programs. Its most tangible feature is per-package caching: reusing package-related work to reduce loading time and memory overhead. For an application team, that raises a useful question—does the new execution layer improve the transactions your product actually runs? This guide connects the March announcement, April release record and later incident report, then turns them into a practical compatibility and performance checklist. It explains the engineering change; no independent application benchmark is claimed.
There are three layers to keep in view. First is the VM design: caching, type handling and execution across packages. Second is deployment: which software and protocol version your environment runs. Third is the application result: loading time, execution time, memory and end-to-end behaviour under a representative workload. Stablecoins such as USDsui belong to a separate asset-and-issuer decision, covered below. Keeping those layers distinct makes the upgrade easier to evaluate without turning a technical announcement into an investment forecast.
What changed after the announcement?
Sui VM: announcement, release and incident report
March–May 2026
A release record and a later incident report answer different questions. None of these milestones is an application benchmark.
Methodology
Each point is one dated milestone. Vertical position is event order, not a performance or progress score.
Read chart data
| Date | Chronological order | Note |
|---|---|---|
| 1.00 | New VM announcement | |
| 2.00 | Mainnet v1.69.2 release notes | |
| 3.00 | Report on three May halts |
| Dated record | What it adds | Limit |
|---|---|---|
| 16 March 2026 VM announcement | Public code, review window and intended improvements | A target, not a measured application result |
| 8 April 2026 Mainnet release v1.69.2 | Versioned software notes and the protocol activation adjustment | Not an independent timestamp of every node’s adoption |
| 31 May 2026 incident report | Documents three Mainnet halts on 28–29 May | Different failure mechanisms must not be blamed on the March VM rewrite without evidence |
The Sui Foundation’s incident report provides a useful later case study. It attributes the first two May halts to gas-charging interactions with release 1.72’s address balances, and the third to randomness-state handling across validator restarts. Its account describes fixes and resumed activity. The practical lesson reaches beyond faster successful transactions: compatibility work also needs rejected transactions, competing requests for the same funds and recovery across restarts or epoch changes. These are the report’s stated mechanisms, rather than evidence that the March VM rewrite caused the outages.
A small regression matrix that produces useful evidence
| Case to include | Record | Why |
|---|---|---|
| Repeated package calls | Cold versus reused loading and memory | Tests the claimed caching benefit rather than a generic TPS headline |
| Insufficient funds / rejected transaction | Error, effects and gas behaviour | A failed transaction is still a runtime path |
| Concurrent access to shared funds or objects | Outcomes under a representative workload | Serial tests do not establish concurrent behaviour |
| Dependency and version change | Pinned package versions and test results | A release label does not prove application compatibility |
| Service interruption | Client recovery and duplicate-submission handling | An application needs a failure plan, not just a fast happy path |
Use this proposed matrix to organise a comparison in an appropriate test environment, following the project’s documented procedures. Give each case an expected outcome before running it and retain both successful and failed results. For the balance-related cases, record the error and effects as well as elapsed time; for recovery, record what the client does after an interruption. That produces a more useful migration record than a single transactions-per-second figure. The matrix is a test plan, not a report of tests performed by WHIUAE.
In This Article
- Inside the VM: Package Loading, Types and Execution
- Package Compatibility and Move Language Support
- Security Review, Release Versions and the Bug Bounty
- What Changes for Applications—and What Belongs to the Asset Issuer
- Frequently Asked Questions
Inside the VM: Package Loading, Types and Execution
Sui’s 16 March 2026 VM announcement identifies changes to package caching, type storage and resolution, execution across packages and interpreter processing. Those are the components to investigate when evaluating the rewrite. A throughput number combines many parts of a running system, so use the particular software version, workload and measurement method alongside any performance claim. The announcement describes the design goals; a comparison of your own application establishes how those goals translate to its workload.
The Foundation describes per-package caching as a way to reduce loading time and improve memory use at scale. For a workload repeatedly calling the same packages, the useful comparison is the first load against subsequent calls, with package and software versions kept in the record. Then examine whether the saving is large enough to affect the user-facing operation. A UAE application team can use the same approach as any other developer: test its own transactions and peak-load assumptions rather than adopting a headline capacity figure.
Loading Time, Execution Time and End-to-End Latency
Execution time is only one part of application latency. Package loading, transaction scheduling, network communication, storage and the client’s own path can affect what a user observes. That is why a VM optimisation does not establish a universal transactions-per-second figure or prove that every application’s bottleneck has moved. Measure the relevant stages separately.
Per-Package Caching: Where to Look for a Benefit
A cache helps most when there is reusable work. Compare repeated calls to the same packages with a workload that touches a wider package set, then report the difference in loading, execution and memory separately. Keep inputs and environment comparable so a hardware or workload change does not masquerade as a VM improvement. The announcement also connects the rewrite with future Move-language features; use the release documentation to identify which features are available in the environment being tested.

Package Compatibility and Move Language Support
Package loading, type resolution and interpreter behaviour are concrete boundaries to examine in the rewrite. Follow a representative application transaction through the interfaces documented for its chosen release: which packages it calls, the inputs it supplies and the stored objects it uses. That provides a clearer compatibility question than a broad promise that processing, execution and storage have become independent. The March announcement describes changes within the execution layer, not complete independence between every blockchain component.
Build a migration comparison around the application’s existing test suite. Pin its package versions and dependencies, run representative transactions on the selected software version and retain their outcomes. Include the cases the product depends on, not just the simplest successful call. If a package-loading improvement appears, record it separately from changes in execution time or full request latency. That turns an architectural change into evidence relevant to the application’s release decision.
Interfaces and Dependencies: What Actually Changes
For each interface change, record the assumption your application makes and the test that exercises it. A package may load correctly while a dependency or transaction outcome differs; a faster execution stage may leave the overall request dominated by another cost. A useful migration note identifies the changed component, the affected operation and the comparison result. That is more informative than describing the entire stack as “decoupled” without naming a boundary.
Debugging a Change: Keep the Failing Case Reproducible
Start a debugging record with the failing transaction, package, input data, network and software version. Retain the observed error and effects, then change one relevant condition at a time when comparing behaviour in the test environment. The May incident report illustrates why rejected and concurrent transactions deserve their own cases: a successful serial run leaves those paths unexplored. This is a proposed investigation method, not a claim that the magazine has reproduced that incident or measured a production improvement.

Security Review, Release Versions and the Bug Bounty
Security review and performance testing supply different evidence. For a review, the useful record is the examined code revision, scope, findings and remediation status. For a benchmark, it is the workload, environment, method and result. Keep both attached to the release decision: a performance improvement answers a capacity question, while an audit finding can change the conditions under which a release should be used.
Sui’s 16 March 2026 announcement describes internal review, multiple independent audits and a public bug-bounty window. The company opened submissions at Mainnet reward rates before the code reached Testnet. That timing matters: the programme was a way to invite scrutiny ahead of deployment. For a present-day report or submission, use the applicable programme terms and the precise code version in scope; the historical announcement alone does not establish today’s reward amounts or eligibility.
Independent Review: What Audits Establish
When comparing audit evidence, start with the report’s version and scope, then read its findings and whether the relevant fixes were reviewed. Attribute an auditor only when the report or an official statement supports the name. The March announcement refers to multiple independent audits without naming firms in that passage. Its useful contribution is evidence of a review process, while individual reports supply the detail needed to evaluate a particular revision.
From the March Target to the April Release
The March announcement’s early-April Mainnet target is now historical. A concrete later record is the official mainnet-v1.69.2 release, published 8 April 2026. Its notes include the new Move VM and record that activation was moved from protocol 118 to 119; the release itself lists protocol 120. A release publication is evidence of shipped software, not an on-chain observation that every validator switched at the publication timestamp. Check the version and protocol of the actual environment you use.

What Changes for Applications—and What Belongs to the Asset Issuer
For an application, the opportunity is to improve a specific part of execution or support a documented language feature. Match that opportunity to a real operation: loading a repeatedly used package, resolving its types or executing its Move program. Then compare compatibility and operating costs under the selected release before changing a service promise. Being based in the UAE does not alter the engineering evidence needed for that decision.
The VM and the assets executed through it need different evidence. Sui’s 4 March 2026 USDsui launch announcement identifies an issuer-backed stablecoin using Bridge infrastructure. That is not a consequence of the VM rewrite, proof of decentralised issuance or a UAE payment permission. For local context, compare our crypto coverage without treating it as approval of an asset or provider.
A Like-for-Like Application Comparison
A useful comparison sheet has four parts: the same representative transactions and inputs; the hardware and network environment; the software, protocol and package versions; and the results for each measured stage. Report package loading, execution and end-to-end latency separately. If one improves while another stays unchanged, preserve both findings. A result becomes useful to another developer when they can identify the conditions needed to reproduce it.
USDsui: A Separate Issuer and Redemption Question
USDsui and the VM should be assessed on different evidence. The VM concerns execution of Move programs; USDsui is an issuer-backed stablecoin built using Bridge’s Open Issuance infrastructure. Before using a stablecoin in payments or DeFi, check the issuer’s terms, redemption arrangements, supported networks and the exact asset identifier. Do not infer those terms from another token with a similar name. An asset being native to Sui does not establish decentralised issuance, reliable redemption or an absence of custody and counterparty risk.


Frequently Asked Questions
What is the primary benefit of Sui’s new VM upgrade?
The announced goals are improved execution performance, reduced memory overhead and support for future Move features. Per-package caching is a specific design change. Actual speed and throughput should be checked against a stated workload and software version; this article does not provide an independent benchmark.
How does ‘per-package caching’ improve Sui’s performance?
Per-package caching reuses package-related work to reduce redundant loading and improve memory handling. The benefit to an application depends on its package-use pattern and the version it runs. A useful comparison measures first-load and repeated-call behaviour, memory use and end-to-end latency under the same workload.
How does the VM relate to transaction processing and storage?
The VM executes Move programs; the rewrite changes package execution, type handling and interpreter processing. An application still needs to supply the transaction inputs and interact with the objects and interfaces documented for its release. Assess those concrete boundaries rather than treating “decoupled” as complete independence between execution, processing and storage.
How is Sui ensuring the security of its VM upgrade?
Sui’s announcement describes internal review, independent audits and a public bug bounty. Those measures support vulnerability discovery and review, but do not prove the absence of faults. Confirm specific auditor reports and current bounty terms before relying on a named firm or reward amount.
What does the April 2026 release record verify?
The initial target was early April 2026. The official mainnet-v1.69.2 release was published on 8 April and includes the new VM, with notes moving activation from protocol 118 to 119. Check your environment’s deployed software and protocol; publication alone does not timestamp every node’s adoption.
What does the VM upgrade mean for the future of dApps on Sui?
The aim is a cleaner execution layer and room for future Move features. The application-level opportunity depends on which features its selected release supports and which parts of the workload change. Check compatibility, loading, execution and recovery separately before turning that design opportunity into a capacity or reliability commitment.
Related Reading: Separate the Technology from the Asset
For a different Sui-linked asset, our suiUSDe/eSui Dollar explainer covers its own backing and yield mechanism. It is a different product from Bridge-issued USDsui. Our Ethereum sentiment and staking guide similarly separates network activity from an investment forecast. A stronger execution engine and a sound investment case require different evidence; crypto assets can lose value.
What a Developer Should Verify
For a release decision, start with the Sui developer documentation and the versioned software notes. Write down the application operation you expect to improve, the compatibility checks it must pass and the failure behaviour it must handle. Then record the actual comparison. The VM rewrite supplies specific engineering changes to investigate; the result of that application-level work is what supports a product’s performance and reliability claims.



