Check This Table Before Enrollment: What Six AI Tracks Need on Windows and Mac ​

We · November 2026

This is the first article in the "AI Learning Environment" series. The series answers four things only: whether it runs, how it installs, how versions line up, and how a lab is managed. For course design see How to Design an AI Curriculum; for choosing between a cloud and a local teaching environment see AI Teaching Environment Selection Guide. Buying machines and sizing them belongs to our hardware series. This article assumes the machine is already there and asks where its ceiling sits.

The configuration numbers here come from the system requirements printed on each app's detail page and from upstream projects' public documentation, compiled in November 2026. Models and versions change monthly, so these numbers are a reference for judgment, not a promise — go by what the page says on the day you install. This article evaluates no institution, recommends no course, and is not purchasing advice.

1. Sort the machines into three classes before asking "is it enough" ​

The most common line in our inbox is "my PC has an i5, can I still learn this?" That question has no answer — not because it's hard, but because the threshold for local AI isn't one continuous scale; it's three different machines. The same "it won't run" hits a different wall on each of them.

Looking at the applications we've compiled, and going by what their detail pages state, user machines fall into three classes:

These three aren't high-spec, mid-spec and low-spec. They're three different answers. Class two gets misread most often: a Mac with 24GB of unified memory holds models that a card with 8GB of VRAM cannot, yet its software ecosystem is narrower, not wider. An Apple-silicon Mac is not a stronger integrated GPU — it's a separate technical line.

The test is simple. Whether something runs depends first on whether there's a matching acceleration backend: NVIDIA cards use CUDA, Macs use MPS/Metal, AMD and Intel Arc use Vulkan, and with none of those you fall back to CPU. Once the backend exists, then look at VRAM. Ranking machines by VRAM alone sorts class two as "VRAM unknown, cannot judge" — when its actual problem sits on the other half of the question.

2. What each of the six tracks needs ​

The table below is the core of this article. The six tracks follow the courses students actually enrol in: AI image, AI voice, video generation, digital humans and lip-sync, local model chat, and the AI comic-drama pipeline. Each cell answers one question — is it enough — and skips the parameter detail.

Three notes.

First, this table reads tracks, not apps. Inside one track, apps differ by several times. Under the same heading of voice, the original wants 8GB of VRAM and the lite edition starts at 4GB. Under the same heading of image, 4GB works on a small model, while the mainstream community's benchmark for comfort is 12GB. The track decides whether you enrol; the app decides which one you install afterwards.

Second, the Mac columns come down to one sentence. Detail pages write macOS support one of two ways: M-series chips only, or supports Intel and M-series chips. An older Intel Mac counts the second one only. If macOS isn't mentioned at all, the app is Windows-only — that's not an omission. You can check this yourself before enrolling, without reading specs or asking anyone.

Third, disk is the most ignored column here. "It runs but I can't fit it" is common: the app itself is tens of megabytes, the first model weights are counted in gigabytes, and by the third model in a track you're at tens of gigabytes. So when you read a requirement, add the app and its first weights together instead of sizing your free space to the installer.

One aside: series eight already covers which tools each track uses and how those tool lines differ technically — why image and video work keeps landing on the same workflow in Local AI Images and Video, and why voice AI is really three separate things in Speech AI Is Really Three Things. This article doesn't repeat that material; it only looks at thresholds.

Writing these requirements out line by line, and giving an installable version per app and per platform, is a gap the local AI tool chain is still filling. Some one-click deployment tools already put the system requirements and the lite-edition mapping directly on the app detail page. As for what kinds of desktop clients exist for local models, No Command Line, No Single App: Choosing a Desktop Client for Local Models covers that.

3. Three traps in reading a config table ​

Trap one: treating memory as VRAM, and VRAM as performance ​

The two numbers aren't interchangeable. Memory decides whether the model fits at all; VRAM decides whether a step runs fast — or runs at all.

Two real examples. Ollama states memory on its detail page, not VRAM: 7B needs at least 8GB, 13B at least 16GB, 33B at least 32GB. The reason is that quantized weights live mostly in memory and the card carries only part of the compute. LM Studio simply states M-series only on the macOS side, which works for the same reason — the large model sits in unified memory. On the image and video side it inverts: weights that don't go to memory have to go to VRAM, and when they overflow you get an out-of-memory error, at which point 32GB of RAM cannot rescue 4GB of VRAM.

Apple-silicon machines need their own conversion: unified memory is shared between the system and the GPU, and only part of it is normally available to the model, so 16GB of unified memory is not 16GB of VRAM to compare against. That's why the Mac columns in the table list memory tiers — 16GB / 24GB / 32GB — rather than VRAM.

Trap two: treating "it infers" as "it hands in homework" ​

Coursework splits into generation and training. The first takes weights that already exist and produces a result; the second builds a model out of your own material. The two thresholds aren't the same order of magnitude.

With voice-cloning tools, pure inference produces a result even on CPU. The moment an assignment says "make a voice from three recordings of your own," you're in the training step, and VRAM, runtime and disk all have to be recalculated. The question to ask before enrolling is "does the coursework include a training step," not "does the software open." We've noticed that most cases of a successful install and a missing assignment come from these two steps being treated as one.

Trap three: treating "the docs don't say" as "it can't run", and "the docs say so" as "it will work" ​

Both misreadings, in the opposite direction, are expensive.

One side: upstream not mentioning macOS doesn't mean Mac students can't take that track. Usually the official documentation only tested CUDA, and someone in the community has long since got it running on MPS. These cases are worth asking about and worth trying — just don't turn "not written" into "doesn't work".

The other side matters more: support stated doesn't mean usable once installed. In the generative ecosystem a large share of custom nodes and operators are implemented against CUDA. Missing operators on MPS are routine; the error reads like a broken environment, when in fact that particular path simply isn't wired up on this machine. So in a config table the word "supports" covers one layer only: it installs, and the main flow runs.

4. A weak machine isn't disqualified: there are four ways down ​

For class-three machines the question isn't "does it run" but "when it doesn't, which step do I drop to". Reading across the applications we've compiled, we see four downgrade paths, ordered by what they buy you:

The shared precondition for all four is that the downgrade has to be written into the course, not something a student finds by crashing into it. A lite edition was never positioned as "the same as the original"; it trades speed for space. For a three-minute Chinese script, being able to produce audio and being able to produce it the same day are two different things for a class cadence. That's also what the question "does it run" should be answered as: not yes or no, but how far it goes, how slow it gets, and whether there's one more step down.

5. Finish these four questions before enrolling ​

This checklist is the only thing to carry out of the article. Students can use it on themselves, and an institution's admissions desk can use it as-is.

1. Which of the six tracks am I signing up for? For a combined track, judge by its most expensive step: in a comic-drama pipeline, the image and video stages set the line for the whole chain, and how light voice and transcription are won't pull the total down.
2. Which of the three classes is my machine? The test isn't brand or CPU model, it's backend: a discrete NVIDIA card, an Apple chip, or CPU only. 8GB of VRAM is the densest dividing line across these applications — above it "runs at class pace", below it "pick a downgrade tier".
3. Does the course depend on nodes or workflows that support CUDA only? Mac students have to ask this one. If nobody can answer, write down each app the course uses and check the two macOS lines on each detail page. That beats asking anyone.
4. When it won't install, is there a downgrade path written into the course? Switch to lite, drop the resolution, or move that step to the lab. Of the four questions, this one best separates "they thought about this" from "they didn't".

The institution-side questions are outside this article. How to state hardware requirements and refund boundaries clearly during pre-sales enquiry is what article four of this series handles. One thing stays here: not one of these four questions requires a student to be technical. They only break the word "enough" into boxes you can check.

6. Our view ​

First, treat the configuration question as a table rather than a number. VRAM is one dimension of it. Backend support, memory, disk and whether a downgrade exists — those four together make an answer. Any single sentence of "yours is enough" or "yours isn't" throws away the other three.

Second, Mac students shouldn't be left outside the answer. People who learn AI aren't the same population as ordinary desktop users: creative tracks carry a visibly higher share of Macs than these courses usually assume. In the catalog we've compiled, apps that state macOS support are already the majority. But "support" comes in two kinds: it installs, and it runs a whole course without friction. Between those two layers sit operators, nodes and runtimes — and that middle stretch is what this series intends to explain article by article.

Third, a problem that isn't solved before enrollment doesn't solve itself afterwards. The most regrettable kind of environment dispute is both sides meaning something different by "it runs". The institution means "this software installs"; the student hears "I can do the assignment at home". Opening that gap up during the enquiry call is far cheaper than repairing it later. It's also why this series judges no institution and gives only tests and methods.

What a machine really decides is the way you study, not whether you're allowed to. An 8GB-VRAM PC and a 24GB-memory Mac overlap heavily in what they can teach; only the walls and the way down differ. Class three is a different case: if a course quietly assumes "every machine is class one", that student hits a wall in week one that nobody mentioned. Knowing which class you're standing in comes before reading the syllabus.

Disclaimer: The configuration figures in this article come from the system requirements carried on each app's detail page and from upstream projects' public documentation, compiled by us in November 2026. Software and model versions update monthly and the figures may change; the numbers here are a reference for judgment, not a guarantee that any app will run or deliver on your device. This article evaluates and recommends no training institution or course.