Intel Macs had a CPU with its DRAM and a GPU with a framebuffer you copied into. Apple Silicon (M1 and successors) puts high-performance cores, efficiency cores, GPU, and Neural Engine on a unified memory architecture: one pool, one coherency story, no PCIe copy of a 4K frame just to filter it. Apple's developer sessions and Metal docs emphasize storage modes (shared, private, memoryless) because the old "upload to GPU" instinct can now waste bandwidth or, worse, force extra copies the hardware did not need. For apps, this is the biggest architecture change since the Intel transition: the same megabytes are visible to vDSP, Metal, and Core ML, if you do not fight the memory model.

Shared does not mean free

Unified memory raises the ceiling and the confusion. A MTLBuffer in shared mode is CPU-writable and GPU-readable with coherence rules you must still respect (encode a blit or wait on a command buffer before the CPU reads GPU output). Treating shared buffers like malloc without synchronization is a race, not a simplification. Private GPU-only resources remain faster for purely GPU data because they can live in layouts the CPU never touches. Memoryless render targets on Apple GPUs exist because tile memory can hold a depth buffer that never lands in DRAM — a win that disappears if you "helpfully" copy it out.

Bandwidth is still finite. Unified does not mean infinite HBM. A 16 GB MacBook Air is sharing that pool among display compositor, browser tabs, and your model. Memory-mapping a huge file and expecting the GPU to page it kindly will jet-wash the working set. Apple's instruments (Metal System Trace, counters) are how you see whether you are bound on memory bandwidth vs. ALU.

Porting, Rosetta, and the apps that still copy

Rosetta 2 made the CPU transition gentle; it did nothing for apps that still staged OpenGL-era copies. Native arm64 + Metal is where unified memory pays. Creative apps that rebuilt their pipeline around zero-copy IOSurface and Metal shared textures saw real battery and export-time wins. Apps that kept a "staging texture on GPU, memcpy from a CPU bitmap" left performance on the table and burned energy on laptops without fans.

For on-device models, Core ML's ANE and GPU backends sit on the same fabric, which is why a large language or diffusion model on M-series parts is a memory-resident problem first. Quantization is as much about fitting the unified pool as about math. iPhone and Mac share the architecture idea with different pool sizes; an iPad Pro is not a Mac Studio.

The steal on any SoC with UMA (not only Apple) is: design algorithms so producers and consumers share buffers with explicit handoff, measure bandwidth, and stop copying "because that's how dGPUs worked." Apple Silicon made the wrong copy obvious in Instruments.

Quality-of-service and core allocation still matter. A Metal-heavy export job that ignores efficiency cores vs. performance cores can either steal interactive UI or run slower than expected if it fights the scheduler. Use the concurrency APIs Apple documents for "this is user-initiated" versus "this is background maintenance," and cap concurrent GPU-heavy tasks. Unified memory does not mean unlimited concurrent writers to the same pool.

What you can borrow

  • Prefer zero-copy shared buffers with explicit CPU/GPU handoff over upload/download pairs.
  • Keep GPU-private resources when the CPU never needs the bytes; shared is not always faster.
  • Budget the unified pool as a single scarce resource (UI + compute + models).
  • Profile bandwidth on battery-constrained devices; UMA does not cancel thermals.
  • Delete leftover discrete-GPU staging copies after a platform transition. They quietly dominate frame time.