Skip to content
← Newsroom
HardwareWorldwide

Microsoft's Project Zenith Windows build needs 64GB memory and 250GB/s bandwidth for local AI

A developer edition of Windows specified around memory bandwidth shows what running 30B-parameter models on a desk really requires.

Square 1 AI Newsroom5 min read

Microsoft has announced a slimmed-down edition of Windows 11 aimed at developers who run large AI models on their own machines, and its first home will be AMD's Ryzen AI Halo platform. The variant, called Project Zenith, was described on the Windows Blogs on 4 September and reported by Tom's Hardware on 5 September. Microsoft pitches it as a ready-to-code, distraction-free Windows experience for developer-class devices.

The hardware bar is unusually high for a Windows edition. According to the report, Project Zenith calls for at least 64GB of unified memory and 250GB/s or more of memory bandwidth, a combination chosen so the machine can run models with 30 billion or more parameters locally. That rules out most mainstream laptops and desktops and points squarely at systems built around chips that share one large pool of memory between the CPU and the GPU.

Rather than a bare operating system, the build ships with a developer toolchain preinstalled: Visual Studio Code, GitHub Copilot, PowerToys, Windows Dev Skills, Intelligent Terminal, PowerShell 7, Git, the GitHub and Azure command-line tools, Python 3.14 or later, Node 24 or later, WSL 2 with Ubuntu, and .NET 10. Microsoft framed part of the motivation around token costs, noting that AI agents consume around a thousand times more tokens than conventional AI applications, which makes local inference attractive for people who iterate all day.

Initial availability is limited to AMD Ryzen AI Halo systems, with Microsoft saying it intends to bring the build to other OEM and silicon partners later. Tom's Hardware cited one Ryzen AI Halo configuration, pairing a Ryzen AI Max+ 395 with 128GB of LPDDR5x-8000 memory, a 2TB SSD and Radeon 8060S graphics, at $3,999.99.

Why it matters

An operating system vendor publishing a memory bandwidth requirement is a sign of where the personal computer is heading: the machine is being specified around inference rather than around office work. The unified-memory design that Apple popularised is now the reference point for Windows developer hardware too. If agents really do burn a thousand times more tokens than chat, then the economics of doing that work on a local device, once, rather than paying per token, start to look different. Expect more products to be sold on gigabytes and gigabytes-per-second rather than on clock speed.

The local inference stack Project Zenith targets

Developer tools

VS Code, GitHub Copilot, WSL 2 with Ubuntu, Git, Python 3.14+, Node 24+, .NET 10 preinstalled.

Project Zenith Windows 11 build

A stripped-down, ready-to-code edition for developer-class devices.

Model weights, 30B+ parameters

Loaded once into shared memory; quantisation decides how many bytes each parameter takes.

Unified memory: 64GB+, 250GB/s+

Capacity decides whether the model fits; bandwidth sets the tokens-per-second ceiling.

AMD Ryzen AI Halo SoC

CPU and GPU address the same memory pool, so no copy across a bus is needed.

What you can learn from this

  • Unified memory means one pool shared by CPU and GPU. In a conventional PC the processor has its own RAM and a discrete graphics card has separate, smaller video memory, and data must be copied across a bus between them. In a unified design such as Ryzen AI Halo, both engines address the same physical memory, so a large model can be loaded once and used by whichever engine is fastest for the job. That is why a 128GB machine can hold a model that a 24GB graphics card cannot, even if the graphics card is faster at raw arithmetic.

  • Memory bandwidth, not compute, usually limits local inference speed. Generating each token requires reading essentially every parameter of the model from memory, so the ceiling on tokens per second is roughly bandwidth divided by model size in bytes. A 30-billion-parameter model stored at two bytes per parameter is about 60GB, and at 250GB/s that reads out only a few times per second. This is why Microsoft's requirement lists bandwidth alongside capacity: capacity decides whether the model fits, bandwidth decides whether it is usable.

  • Quantisation trades precision for fit and speed. Model weights are commonly trained at 16 bits but can be stored at 8 or 4 bits with modest quality loss, halving or quartering both memory needed and bytes read per token. That is the trick that makes a 30B model practical on a 64GB device with room left for the operating system and your tools. It works because most weights carry little information individually, so coarse rounding changes the output surprisingly little.

  • Local inference changes the cost curve from variable to fixed. Cloud APIs charge per token, so an agent that loops through thousands of tool calls has a bill that scales with activity. A local machine costs the same whether it produces one token or a billion, so the more you use it the cheaper each token becomes. The trade-off is that the local model is usually smaller and slower than the frontier model in the cloud, so the decision depends on the task.

  • A preinstalled toolchain is a product decision, not a convenience. Bundling WSL 2, Git, Python and Node makes a new device usable within minutes and standardises the environment across a team. It also means those versions are the ones the vendor tests against, which is why such images pin minimum versions such as Python 3.14 and Node 24. Understanding what is pinned tells you what will be supported and what you will have to manage yourself.

How to use this in practice

  • Measure the two numbers that matter on your current machine. On Windows, run wmic memorychip get capacity,speed or open Task Manager's Memory tab; on Linux use sudo dmidecode -t memory. Multiply the memory clock by the bus width in bytes and channel count to estimate peak bandwidth. Done is a note with your capacity in GB and estimated bandwidth in GB/s, so you know how far you are from the 64GB and 250GB/s bar. Record where each number came from. Laptops with soldered LPDDR5x typically report higher bandwidth than desktops with two DIMMs, which is exactly the difference the Ryzen AI Halo design exploits.

  • Run one local model and calculate your own tokens-per-second ceiling. Install Ollama or llama.cpp, pull a small quantised model that fits in your RAM, and time a fixed prompt. Compare the measured rate to bandwidth divided by the model's file size. Done is a two-line table: predicted rate, measured rate, and one sentence on why they differ. Try the same model at two quantisation levels if your memory allows, and note how both the rate and the answer quality change.

  • Set up the same environment Zenith ships with, by hand. Enable WSL 2 with Ubuntu, install Git, Python and Node at the pinned minimum versions, and verify with python --version and node --version. Done means you can clone a repository, create a virtual environment, and run its tests without leaving a fresh terminal. Then install one local model runtime inside WSL and check whether it can see your GPU or, failing that, how many CPU threads it uses.

  • Draw the inference stack as layers. Sketch, top to bottom: your editor and agent, the runtime such as llama.cpp, the model weights, unified memory with its bandwidth figure, and the SoC. Done is a diagram where you can point to the layer that would bottleneck a 30B model on your own hardware. Write the bytes-per-token calculation beside the memory layer so the arithmetic is on the page, and keep it for when you compare a cloud GPU.

Sources

Our reporting is an original summary; full coverage is at the links above.

Don't just read about it — build it.

Square 1 teaches the skills behind the headlines, with every line of your work graded by AI. Find your starting point in 3 minutes.

Get your free skill report

More in Hardware