Solana programs that touch memory they should not are about to start failing on mainnet. Anza told developers on 19 November 2026 that direct mapping, a breaking change for programs, is "heading for mainnet activation this cycle", and the first of its two switches is scheduled to activate at epoch 1092 on Solana SOL$72.00-2.7% mainnet.
Most programs will keep working unchanged. The ones that read past the end of an account, write to accounts they do not control or depend on the layout of their own stack will start returning errors.
When Solana's direct mapping gates activate on mainnet
The first gate, virtual_address_space_adjustments, is listed as "Pending activation on Mainnet" for epoch 1092 on the Solana Explorer. It adds the new memory checks, and it is the gate that can break programs. The second gate, account_data_direct_mapping, does the mapping itself and shows as "Not active yet" with no mainnet epoch set.
Epoch 1092 had not started at the time of writing. On Solana Compass epoch data, epoch 1091 began at 11:02 UTC on 19 November and the last full epoch ran about 25.9 hours. That puts the start of epoch 1092 at roughly 12:50 to 13:00 UTC on 20 November.
That clock time is our estimate from slot pace; no official time is published, and the gate switches on at the epoch boundary whenever it lands. The Solana Compass epoch countdown tracks the boundary live.
The timing follows the end of a release pause around Breakpoint. Anza's Agave v4.5 release schedule marks mainnet feature activations as resumed on 19 November, and separately targets 14 December for the start of v4.5's own feature activations. Direct mapping sits outside that later batch: both of its gates already ship in the validator releases mainnet runs today, so node operators have nothing to install. As we noted when Anza published the v4.5 schedule, direct mapping was among the gates planned for this cycle.
The Solana Foundation's direct mapping upgrade guide lists the checks gate as "Live in Epoch 1092" in its status table, while its summary row still gives the expected mainnet date as "to be determined". The on-chain schedule shown by the explorer is the firmer of the two.
What Solana direct mapping changes for program memory
Direct mapping removes the copying of account data in and out of a program. Today, before a program runs, the validator copies each account's data into the program's virtual machine, then copies it back afterwards and compares the two to see what changed. Calls from one program into another, known as cross-program invocations (CPIs), repeat the copy in both directions.
The Foundation guide counts up to four copies per instruction. With account_data_direct_mapping active, the virtual machine points at the account data where it already sits in validator memory, so none of the copies or comparisons are needed. Instructions that make CPIs or touch large accounts save the most.
Removing the copies also removes the safety net. When a program works on a copy, the runtime can catch a bad write at the end by comparing. When it works on the original, every read and write has to be checked as it happens, and those checks are what virtual_address_space_adjustments adds.
Anza and the Firedancer team split the original proposal, SIMD-0219, into separate gates so each part could ship and be tested on its own. The checks go first so any breakage can be traced to the checks alone, according to the Foundation guide. The checks are specified in SIMD-0460, written by Alexander Meissner of Anza; account_data_direct_mapping has no SIMD of its own.
Which Solana programs break under the new memory checks
The Foundation guide lists five access patterns that fail or change behaviour once virtual_address_space_adjustments is active. Each failing access aborts the transaction with a specific error:
| If a program | Error returned |
|---|---|
| Reads past the end of a read-only or foreign-owned account | AccountDataTooSmall |
| Reads past the end of a writable account it owns | InvalidRealloc |
| Writes to an account not flagged writable | ReadonlyDataModified |
| Writes to an account it does not own | ExternalAccountDataModified |
| Writes past the maximum account size or growth limits | InvalidRealloc |
Two further changes come from SIMD-0460. A single load, store or syscall that spans two memory regions, such as copying an account's 8-byte length field and its data in one go, becomes an access violation; this mostly affects unsafe Rust and hand-written syscalls. And the unmapped gaps between stack frames are removed for every program, including older sBPFv0 programs.
The stack change is the one to worry about, because it can fail silently. An overrun that used to hit a gap and stop now reads or writes the neighbouring frame, and the program carries on with the wrong data. The guide says Anza's replay of mainnet traffic found one program using slightly fewer compute units with the gate on and no other difference, with an out-of-bounds stack access the suspected cause.
Two fixes do not work, the guide warns. Catching the error in a calling program fails because the error aborts the whole transaction. Writing a value and then restoring the old bytes also fails, because the runtime checks each write as it happens.
Resizing is a common trap, the guide adds. AccountInfo::realloc called without zeroing grows an account without writing the new bytes, so the first read of them fails; resize, which always zero-fills, is the replacement. Anchor's realloc constraint needs v0.32 or later or realloc::zero = true, and Pinocchio needs v0.9 or later.
Anchor programs have one more issue. Anchor writes every mutable typed account back when a handler returns, even when a CPI has reassigned that account to another program, and under the new rules that write fails with ExternalAccountDataModified. The fix, Anchor pull request #5011, ships in Anchor v1.2.2.
Who needs to act before the Solana mainnet activation
Users and validator operators have nothing to do, and wallets, indexers and front ends need no code changes because the transaction format, RPC methods and account data are unchanged, per the Foundation guide. The work falls on program developers. A program is at risk, the guide says, if it reads account bytes directly rather than through the SDK's account types, uses unsafe blocks or raw pointers, resizes accounts, or runs on Anchor before v1.2.2 and reassigns a typed account through a CPI.
A violation rarely takes down a whole program. Usually one instruction fails, such as a close, a resize or a particular CPI path, which is why the guide asks developers to test every instruction. A failed transaction changes no account state but still pays the normal fee. Immutable programs, which can no longer be upgraded, cannot be fixed in place; they need a new program and a user migration.
How to test a Solana program for direct mapping
Both gates have been live on Solana's devnet and testnet since May 2026, per the Foundation guide, so a program deployed there already runs under the new rules. Local test tools differ in their defaults:
-
solana-test-validatorturns both gates on by default; starting a fresh ledger with them deactivated reproduces today's mainnet for comparison. - LiteSVM starts with the mainnet feature set, so both gates are off until activated in code.
- Mollusk turns every gate on by default; switch the two off and rebuild the program cache to compare.
- Surfpool starts with gates off; pass both gate addresses with
--feature.
The two gate addresses, and the commands the guide gives for the CLI checks:
# Check a gate's status on a cluster
solana feature status 7VgiehxNxu53KdxgLspGQY8myE6f7UokaWa4jsGcaSz --url <cluster>
# Local validator with both gates off (mainnet today); --reset is needed if test-ledger exists
solana-test-validator --reset --deactivate-feature 7VgiehxNxu53KdxgLspGQY8myE6f7UokaWa4jsGcaSz CR3dVN2Yoo95Y96kLSTaziWDAQT2MNEpiWh5cqVq2pNE
# Surfpool with both gates on
surfpool start --feature 7VgiehxNxu53KdxgLspGQY8myE6f7UokaWa4jsGcaSz --feature CR3dVN2Yoo95Y96kLSTaziWDAQT2MNEpiWh5cqVq2pNE
For real traffic, the guide points to SVM Scope, a community tool that replays mainnet transactions from the last 30 days. A transaction that passes with the "direct mapping" gate off and fails with it on belongs to a program that needs a fix. Beyond that, the guide's checklist is short: search the code for unsafe, raw pointer casts and realloc, and if none appear and the Anchor issue does not apply, the risk is low.
Remediation so far: Solana Foundation says risky programs have upgraded
Anza replayed mainnet transactions and contacted the teams whose programs would fail, according to the Foundation guide, which adds that the replay only covers traffic Anza has seen. Jonas Hahn of the Solana Foundation's developer relations team wrote on 20 November that every program with potentially dangerous divergences has upgraded, while some programs will still see failed transactions or different error codes.
In the same post, Jonas Hahn asked developers to test their programs with virtual_address_space_adjustments enabled and listed 22 program addresses. The post gives addresses only, without saying which teams run them or how each one diverges.
What Solana direct mapping enables: deeper CPI nesting
The longer-term payoff is composability. Solana caps how deep programs can call into one another at four levels of CPI, and SIMD-0268 would raise that to eight. The proposal must activate after the SIMD-0219 work that direct mapping completes, and the Foundation lists no mainnet date for it yet.
Deeper nesting helps programs that wrap other programs, and the Foundation's CPI page cites smart wallets as an example. The same page notes that indexers and tools which hardcode the current depth will need updates when that change lands.
What to watch after epoch 1092
Once epoch 1092 begins, these are the signals to check:
- The explorer status for
virtual_address_space_adjustments, which should move from pending to active at the boundary. - Mainnet program logs showing the new error names, such as
AccountDataTooSmallorExternalAccountDataModified, on instructions that passed before. - A mainnet epoch for
account_data_direct_mapping, the gate that removes the copies and clears the way for SIMD-0268's deeper CPI calls.