It Is Not NVIDIA or Nothing: How Far Macs, AMD Cards and 4GB GPUs Actually Get ​

We · November 2026

This is the seventh and final article in the "AI Learning Environment" series, written for the people who arrive holding a 'non-standard' machine: students, parents, and admissions staff who check on a student's behalf first. The six before it covered what machine each of six tracks needs, why week one stalls, how a comic-drama splits into six stops, how to state requirements during an enquiry, how an institution pins a course version, and how to staff a mixed room. This one closes the series by answering the question we hear most in enquiries: "my machine doesn't have an NVIDIA card — does that mean I can't learn this?"

The answer isn't "yes" or "no", it's four classes of machine, each following its own backend route. What this article gives is a list and its tests, with every cell pointing at text a reader can open themselves; where we haven't verified something we say so, and we draw no "it all runs" conclusion. The statements here were compiled in November 2026, and since software and models update monthly they are a reference, not a guarantee.

1. The conclusion first: four machine classes, three answers ​

Spread out what "not an NVIDIA card" actually contains and it's four classes. Their answers differ, and answering them with one sentence misleads one of them.

The order of judgment is the same as article one: ask first whether a matching acceleration backend exists, then ask about capacity. This article applies that order to four classes of machine and produces the "how far does it get" list.

Boundaries first, so nothing repeats:

• The by-track configuration table (six tracks by minimum and recommended) is in article one.
• "How far along the pipeline does this machine get" is in article three. Where this article touches video and digital humans it describes only that machine class's status; it doesn't restate the per-stop thresholds.
• How to read errors and the four version layers are in article two. This article only asks whether a path is open, not how versions drift.
• How an institution schedules around Mac students and staffs support is in article six.

2. What a backend is: four routes, one line each ​

When an AI app runs a model, it either uses graphics acceleration or computes on CPU. GPU acceleration isn't one thing; it splits by vendor, and Install NVIDIA Drivers and CUDA explains where CUDA and AMD's ROCm come from. Nobody learning AI needs the implementation — only the four routes:

Once the backend exists, then look at VRAM or memory. Ranking by VRAM alone sorts Mac users as "unknown capacity, can't judge", when their problem sits on the other half — that was article one's judgment about three machine classes, and this article runs on it throughout.

One more sentence up front, so it doesn't repeat with every test: the word "supports" covers one layer only — it installs and the main flow runs. A page stating macOS support does not mean the specific workflow your course uses completes on MPS; that is precisely the most misread point on the Mac side.

3. Apple-silicon Macs: widest for running models, generative work checked case by case ​

Apple-silicon Macs use MPS/Metal. They have no concept of "VRAM"; unified memory is what's available, so on the capacity side they're usually roomier than a card at the same price, and the blocker is normally ecosystem coverage.

On the run-a-model-and-produce-a-result side, support is widest. For voice, voice conversion, transcription, local chat and translation, many detail pages state in the macOS line simply "supports Intel and M-series chips" — GPT-SoVITS and SenseVoice both read that way. On the local chat side, Ollama's macOS statement is "M-series recommended".

For generative work (image and video) there are two tests, both printed on pages.

The first is on the app detail page. ComfyUI's macOS line reads "M-series chip required" — pages like this give you the range in which it installs. The Windows line on the same page reads "CPU usable but with poor compatibility; NVIDIA GPU with 4GB+ VRAM recommended", which states plainly what the generative apps ask of a machine.

The second is on the workflow page. Whether a given Mac runs a given workflow depends on what that page's hardware-requirements block says. Two wordings, two answers. Where it reads "when running on macOS with M chips, change the device parameters of the two SeedVR2 custom nodes to mps", one parameter change gets you there. Where it reads "this LoRA is currently tested only on Windows and doesn't work well on macOS", the path simply isn't open on this machine. Both sentences are from our own workflow pages, and article six uses them to show how an institution should handle Mac students.

On training, we draw no conclusion for Mac. The app most often named by courses is Kohya-ss, and its detail page does not state macOS — by our rule, "not written means treated as Windows-only", so neither an Intel Mac nor an Apple-silicon Mac is inside the stated range. We don't recommend answering this tier with "I've heard it works", and we don't recommend an institution treating a Mac student's training assignment as feasible by default.

One trap worth mentioning: Docker doesn't rescue MPS. Some apps can be installed in Docker mode (How to Install Applications with Docker on Windows), but that same document states that macOS does not support calling MPS through Docker, and applications with high GPU requirements that use MPS will not run properly. Docker solves dependency isolation, not a missing backend: a generative app that won't run on a Mac will usually still not run when installed a second time via Docker.

The three tiers: minimum — voice, transcription, chat and the lite music editions, from 16GB of unified memory; recommended — the above plus image generation, with 24GB or more of memory; not advised — treating video generation and training as this machine's default tasks.

4. Older Intel Macs: only the tier that states "supports Intel" ​

The test here is harder than the Apple-silicon one, because there's nothing to guess: detail pages write macOS two ways only — "M-series chips only", or "supports Intel and M-series chips". Article four used that sentence as admissions wording; this article uses it as an installation test — same sentence, two jobs.

An app that states "supports Intel and M-series chips" will install on an older Mac. That group is fairly common among voice, transcription, translation and office tools: GPT-SoVITS, SenseVoice and HY-MT 2 all read that way on their detail pages.

Apps that state "M-series chips only" (ComfyUI, LM Studio, HeartMuLa among them) put an older Mac outside the range. That isn't a high-or-low configuration question; the machine simply doesn't have that backend, and more memory can't buy one.

One further tier needs separating: on an older Mac, a lite edition runs in CPU mode. The voice lite editions (Qwen3-TTS lite and IndexTTS 2 lite) state "supports Intel and M-series chips" on the macOS line, and on the Windows line state "CPU operation is slow, and some older CPUs may be unable to generate at all". The lite edition launch announcement singles out the Mac case: Intel Macs can install the lite editions but only in CPU mode, at clearly reduced speed.

So the honest answer for this class is one qualified sentence: some apps run; don't chase performance. It suits learning the method, producing samples, and following the transcription and voice stops. It does not suit being the course's primary delivery machine. If the course requires "train a model on your own material" as graded work, get that sentence answered before you enroll.

5. AMD and Intel Arc cards: the Vulkan route, and today the pages state voice and music ​

This class is a Windows machine whose card simply isn't NVIDIA. It travels the Vulkan backend.

In the catalog we've compiled, the voice and music lite editions state this route most clearly. Three detail pages use the same sentence on their Windows line: "GPU acceleration available (NVIDIA / AMD / Intel Arc discrete graphics), with more than X GB of VRAM" — 2GB for the Qwen3-TTS lite edition, and 4GB for the IndexTTS 2 lite edition and the YuE2 lite edition. The lite launch announcement explains the mechanism: these builds move the acceleration backend from CUDA to Vulkan, and because Vulkan is an open cross-platform graphics API, AMD and Intel Arc cards get GPU acceleration too.

An AMD or Intel Arc card with 4GB or more — machines that previously couldn't install the originals at all — is now a formally supported lite-edition tier. Of the four classes in this article, that's the only one somebody adapted something specifically for, which is why it goes first.

Below that comes the honest part, in two pieces.

One: the status of generative work (image and video) on non-NVIDIA cards is not something we've verified app by app. There is exactly one test I can give, and it's hard: the runtime-environment options in the client appear only on Windows machines with an NVIDIA card installed, and with other brands of card those options are not visible at all (verbatim from Deploying ComfyUI with One Click: Choosing the Right Runtime Environment). So whether an AMD machine gets from ComfyUI to a finished image is not a conclusion we'll write. If you want to do generative assignments on such a machine, treat enrollment as "try it first", never as "it should be fine".

Two: when a page says "Intel, AMD CPU usable", it means the CPU, not AMD GPU acceleration. The Windows line on GPT-SoVITS, SenseVoice and HY-MT 2 reads "Intel and AMD CPUs usable, NVIDIA GPU recommended" — that is about CPU mode running on Intel and AMD processors, a different matter from whether an AMD graphics card accelerates anything. In an enquiry those few words get read aloud as "AMD is supported", and the distinction has to be made on the spot. Some apps don't even state a CPU path: HeartMuLa's Windows line reads "NVIDIA GPU recommended (more than 12GB of VRAM); compatibility with Intel and AMD CPUs has not been verified" — and that "not verified" phrasing is, in our view, the most copy-worthy sentence a detail page can carry.

The three tiers: minimum — the voice and music lite editions at 4GB of VRAM (2GB for Qwen3-TTS lite); recommended — the voice lite editions plus transcription and translation, which run on CPU; not advised — treating generative work as a default task, since its status is unverified.

6. 4GB or less, and thin laptops on integrated graphics: lite edition first, CPU second ​

This class has no discrete card, or only a 2–4GB one. There are two routes, in order.

Route one: find the lite edition for this class. Lite editions were built for it. The threshold moves from the original's "NVIDIA, 8GB of VRAM to start" down to the 2–4GB tier, and disk from the 24GB range to the 10GB range (both pairs appear in article one's downgrade table). A lite edition is not a slow version of the same job: on the same three-minute script, the lite edition finished in 39 seconds on our test machine against just over five minutes for the original — a relative gap measured on one RTX 5060 Ti with 16GB, the figure article three used. A Windows machine on integrated graphics completes the job in CPU mode at clearly reduced speed; the positioning stated in the launch announcement is: experience the workflow first, then decide whether to upgrade the hardware.

Route two: accept the apps that work on CPU. Transcription, translation and subtitle tools never depended on a card, and their pages say "CPU usable". They carry the goal of "learn the method, hand in samples".

Image generation has one explicit starting point: the Windows line of the ComfyUI detail page reads "CPU usable but with poor compatibility; NVIDIA GPU with 4GB+ VRAM recommended". So a 4GB card does get started on images, CPU is the fallback with poor compatibility, and that is what the page itself states. Going higher depends on smaller models and heavier quantization — that calculation is done in Parameters, Quantization, VRAM: Why "It Fits" Is Not "It Runs", and isn't repeated here.

On video and digital humans, we give no conclusion at 4GB. Article three works this out along the pipeline: in the smallest working combination, "4GB of VRAM walks it at reduced speed", and stop five (making it move) is the most VRAM-expensive stop, which a 4GB machine basically has to move off. That conclusion is cited here, not recomputed.

The three tiers: minimum — CPU transcription and translation plus the voice lite editions (noting that some older CPUs can't produce a result even on a lite edition; the pages state it); recommended — the above plus 4GB as an image starting point; not advised — treating video generation and digital humans as this machine's assignments.

7. All four classes in one table: read it by backend ​

This table is the axis this article owns: it is organized by backend, not by track. The by-track table is in article one and the by-pipeline table in article three; the three aren't interchangeable.

How to use it: find your machine in the first column, then compare your intended app against that row's "wording you can find on the pages". Anything you can't match — where the page says nothing — is the item to go and ask about, not to guess at.

8. Where we haven't verified, written plainly ​

In an article about whether things run, the most valuable part is often the cells with no conclusion. These are the places we can't currently answer; when you hit them, don't fill the gap with a forum post:

• The status of AMD / Intel Arc on generative apps. Beyond the voice and music lite editions we haven't confirmed anything individually; the first pass covers only that category.
• Video and digital-human workflows that only say "NVIDIA card required" with no VRAM figure. For apps whose statement isn't complete we publish no number, and we don't borrow someone else's.
• Training on Mac. Where the detail page doesn't state macOS, we don't write "it works".
• Workflow entries whose hardware requirements aren't written yet. For those, until the page is completed the only answer is "ask the course provider".

These blanks will be filled, and each one filled widens our stated range by one cell. What costs the most in this trade is saying "everything runs" before the blanks are filled.

9. Three questions to finish before enrolling ​

Take this machine into an enquiry and these three questions are enough; no terminology required:

1. Does this course require a video or digital-human shot as homework? That stop is the most expensive across all four machine classes, so ask about it first.
2. Which class in your catalog is my machine? Send the chip or card model from About This Mac (or About This PC) and have them file it against the three classes in article one.
3. When it can't run, which downgrade does the course actually offer? Lite edition, CPU mode, or moving that step to the lab — you want an answer in writing, not "it's probably fine".

The third is the shared floor across all four classes: a downgrade path written into the course means an under-spec machine isn't a problem; with no path written, any machine can become one. The full six-column checklist for the enquiry side is in article four.

10. Three sentences to carry away ​

First, sort by backend, then discuss VRAM. CUDA, MPS, Vulkan and CPU are four routes matched to four classes of machine. Invert the order and you file Macs as "unknown VRAM" and AMD cards as "definitely can't" — both wrong.

Second, check the verbatim page for every cell and don't take it secondhand. The two macOS wordings on detail pages, the hardware-requirements block on workflow pages, and the lite editions' "NVIDIA / AMD / Intel Arc discrete graphics" sentence — those three together are the entire basis of this list.

Third, "not verified" is part of the answer. We have written out where there is no conclusion, and enquiries and course selection should do the same: when you can't state it, write "unverified". That is worth more than "it all runs".

With this the series ends. Seven articles answer one thing: "does it run" was never a one-word question — it is decided jointly by the machine, the version, the directory and the process. Article one files the machine classes, article two handles version misalignment, article three totals one pipeline, article four covers how to say it clearly before payment, article five covers institutional version pinning, article six covers staffing a mixed room, and this one covers the list for non-NVIDIA machines. Whichever kind of question you arrive with, there is an article for it.

Disclaimer: The configuration statements in this article come from the system requirements carried on app detail pages, the verbatim hardware requirements on our workflow pages, the lite-edition launch announcement, and the PC client documentation, compiled by us in November 2026. Software and model versions update monthly and requirements may change; the lists and tests here are a reference for judgment, not a guarantee that any app will run or deliver on any device. Where this article says "not verified" or "no conclusion", that describes the state of our compiled statements at the time of writing and may be updated as verification is completed. No specific institution or course is referenced or evaluated.