What if memory cost scaled linearly?

bytes32[64] private scratch;

function compute(bytes32 seed) external returns (uint256 sum) {
    for (uint i = 0; i < 64; i++) {
        scratch[i] = keccak256(abi.encode(seed, i));  // SSTORE
    }
    for (uint i = 0; i < 64; i++) {
        sum += uint(scratch[i]);                       // SLOAD
    }
}

function compute(bytes32 seed) external pure returns (uint256 sum) {
    bytes32[64] memory mem;
    for (uint i = 0; i < 64; i++) {
        mem[i] = keccak256(abi.encode(seed, i));       // MSTORE
    }
    for (uint i = 0; i < 64; i++) {
        sum += uint(mem[i]);                            // MLOAD
    }
}

Measured on Monad mainnet: the storage variant cost 2,420,884 gas; the memory variant cost 57,003 gas, a 97.6% reduction. MIP-3 makes memory effectively free for typical workloads. Anywhere a function currently round-trips intermediate values through storage just to read them back in the same call, swap the storage variable for a memory variable. Both transaction hashes are linked below so you can verify the measurement.

// On Ethereum, allocating 1 MB of memory is effectively
// impossible — the quadratic formula charges ~2.3 M gas for
// memory expansion alone, before you store a single byte.
// Devs work around this by chunking, splitting across txs,
// or keeping intermediate state in storage.

// On Monad, the same 1 MB allocation costs ~16 K gas total —
// linear in size. You can write the straight-line algorithm.
function process(bytes32 seed) external pure returns (uint256) {
    bytes memory buf = new bytes(1 << 20);  // 1 MB
    // ... fill, process, fold ...
}

The 'after' tx allocates a 1 MB memory buffer, fills it with 32,768 keccak256 outputs, and folds them, all in one call, in 13.5 M gas (well within a single block). The same logic on Ethereum L1 would pay quadratic memory expansion costs for the intermediate keccak buffers and likely exceed the 30 M block gas limit, forcing devs to chunk the work across multiple transactions. There is no equivalent 'before' tx to deploy on Monad: the same code runs the same way; the difference is which chain can afford it. Reach for the straight-line algorithm.