DGX Spark vs. Mac Studio — you are buying bandwidth, not FLOPs
Local LLM decode speed is bounded by memory bandwidth, not compute: tokens/s ≤ bandwidth ÷ model bytes. That one law reorders the shopping list — a 1-petaFLOP DGX Spark at 273GB/s can chat slower than a Mac Studio at 819GB/s — and the honest third option is renting: a $4k box is ~1,600 H100-hours you could buy by the hour instead.
The test pipeline, cheapest step first — never download 40GB to learn what a hosted call tells you in ten minutes.
1. Sanity-test hosted. Pick the model on the Hugging Face Hub (check the license — some are gated), then run it on a serverless API first: HF Inference Providers, Together, or Fireworks. Ten minutes and a few cents tell you whether the model is worth any local setup at all.
2. Run it locally. Mac: mlx-lm (Apple's MLX) or llama.cpp with a Q4 GGUF from the Hub. DGX Spark: vLLM or TensorRT-LLM with FP8/NVFP4. Same prompt set on both paths.
3. Measure against the law. Record prefill tok/s (compute-bound) and decode tok/s (bandwidth-bound) separately, and compare decode with the ceiling bandwidth ÷ model-bytes. Getting ~70-80% of the ceiling means the stack is healthy; a big gap is a software problem, not a hardware one.
4. Evaluate.lm-eval-harness on a handful of tasks — the point is a repeatable score before and after quantization, not a leaderboard.
5. Fine-tune small. LoRA on both stacks: PEFT/CUDA on the Spark, mlx-lm lora on the Mac — this is where CUDA's ecosystem advantage becomes visible and measurable.
6. Keep the ledger. Every local hour has a cloud price; write both columns down. The ledger, not the benchmark, is the deliverable.
Why
Decode is a memory problem wearing a compute costume. Generating one token reads every weight once, so tokens/s can never exceed bandwidth ÷ model-bytes — a 40GB Q4 70B model tops out near 273/40 ≈ 7 tok/s on a DGX Spark and near 819/40 ≈ 20 tok/s on an M3 Ultra, before software even enters. The Spark's petaFLOP matters for prefill, batching and fine-tuning, which is exactly what NVIDIA built it for; buying it to chat with a big model is buying the wrong axis. The Mac's 512GB @ 819GB/s is the interactive-inference machine; its cost is leaving CUDA — vLLM, TensorRT, most training recipes — for MLX and llama.cpp.
The cloud is the honest benchmark for both. ~$4,000 buys roughly 1,600 hours of an on-demand H100 — a year of 8-hour days — and serverless per-token pricing (a 70B-class model at under a dollar per million tokens) pushes the break-even further out for spiky usage. The rule of thumb: rent while experimenting (RunPod/Vast/Lambda by the hour, Together/Fireworks by the token, Modal for jobs, HF endpoints for a managed deploy), and buy hardware only for the two things the cloud can't sell — data that must not leave the room, and a machine that is hot most of the day.
So the purchase decision is three products, not two. Interactive chat with big models → bandwidth (Mac). CUDA experiments, batch serving, LoRA training → the Spark, or more honestly a rented H100. Bursty everything-else → cloud, with the ledger from the PoC as proof. sub-2bit-local-llm is the same law from the other side — quantization shrinks the numerator's partner, model bytes, which is why 2-bit tricks matter more than FLOPs on every local box — and huggingface-is-a-package-manager supplies the distribution rail this card's pipeline runs on.
How it works
The three boxes (street prices, early 2026 — treat as ~)
DGX Spark
Mac Studio M4 Max 128GB
Mac Studio M3 Ultra 512GB
Price
~$4,000
~$3,700
~$9,500
Unified memory
128GB
128GB
512GB
Memory bandwidth
273GB/s
~546GB/s
~819GB/s
Compute
~1 PFLOP FP4, CUDA
Metal/MLX
Metal/MLX
Built for
Prefill, batching, fine-tuning, CUDA dev
Mid-size chat, dev box
Big-model interactive inference
Largest comfortable Q4 model
~70B (2 linked: ~200B)
~70B
~400-670B class
The law, applied — theoretical decode ceilings (Q4 weights)
Model (Q4 bytes)
Spark 273GB/s
M4 Max 546GB/s
M3 Ultra 819GB/s
8B (~5GB)
~55 tok/s
~109 tok/s
~164 tok/s
70B (~40GB)
~7 tok/s
~14 tok/s
~20 tok/s
405B (~230GB)
doesn't fit (fits on 2)
doesn't fit
~3.6 tok/s
Real numbers land below the ceiling; the PoC's job is to measure how far below, per stack.
The rental menu instead
Service
Unit
Rough price
Use it for
RunPod / Vast.ai
GPU-hour
H100 ~$2-3/h, cheaper spot
Experiments, LoRA runs
Lambda
GPU-hour
H100 ~$2.5-3/h
Same, more managed
Together / Fireworks
per token
70B-class < $1/1M tokens
Spiky inference, no ops
Modal
per job-second
pay-per-run
Batch pipelines
HF Inference Endpoints
instance-hour
managed deploy
Demos, small prod
The break-even, honestly
$4,000 ÷ $2.5/h ≈ 1,600 H100-hours — a year of 8-hour workdays before the box is cheaper.
Serverless makes it worse for chat: at $1/1M tokens, $4,000 is ~4 billion tokens.
What flips the math: data residency requirements, a machine running near 24/7, or the untracked cost of cloud setup friction per experiment.
Electricity is real but secondary: ~200-300W × 8h/day ≈ $10-15/month — the capex dominates.
로컬 LLM 의 디코드 속도는 연산이 아니라 메모리 대역폭에 묶입니다: tokens/s ≤ 대역폭 ÷ 모델 바이트. 이 법칙 하나가 쇼핑 목록을 재정렬합니다 — 1 페타FLOP 짜리 DGX Spark(273GB/s)가 대화에서는 맥 스튜디오(819GB/s)보다 느릴 수 있습니다 — 그리고 정직한 세 번째 선택지는 임대입니다: 4천 달러짜리 박스는 시간 단위로 살 수 있는 H100 약 1,600시간입니다.
테스트 파이프라인, 가장 싼 단계부터 — 호스팅 호출 10분이면 알 수 있는 것을 40GB 내려받아 배우지 마십시오.1. 호스팅으로 정상 확인. 허깅페이스 허브에서 모델을 고르고(라이선스 확인 — 게이트된 모델 있음), 먼저 서버리스 API 로 돌립니다: HF Inference Providers, Together, Fireworks. 10분과 몇 센트로 이 모델이 로컬 설치의 가치가 있는지부터 알 수 있습니다.
2. 로컬 실행. 맥: mlx-lm(애플 MLX) 또는 허브의 Q4 GGUF + llama.cpp. DGX Spark: vLLM 또는 TensorRT-LLM, FP8/NVFP4. 두 경로에 같은 프롬프트 세트.
3. 법칙에 대조해 측정. prefill tok/s(연산 바운드)와 decode tok/s(대역폭 바운드)를 따로 기록하고, decode 를 대역폭 ÷ 모델 바이트 상한과 비교합니다. 상한의 ~70-80% 가 나오면 스택이 건강한 것이고, 크게 모자라면 하드웨어가 아니라 소프트웨어 문제입니다.
4. 평가.lm-eval-harness 로 몇 개 태스크 — 목적은 리더보드가 아니라 양자화 전후의 재현 가능한 점수입니다.
5. 작게 파인튜닝. 양쪽 스택에서 LoRA: Spark 는 PEFT/CUDA, 맥은 mlx-lm lora — CUDA 생태계의 우위가 눈에 보이고 측정되는 지점이 여기입니다.
6. 원장 유지. 모든 로컬 1시간에는 클라우드 가격이 있습니다. 두 열을 다 적으십시오. 산출물은 벤치마크가 아니라 원장입니다.
왜
디코드는 연산의 옷을 입은 메모리 문제입니다. 토큰 하나를 만들려면 모든 가중치를 한 번 읽어야 하므로 tokens/s 는 대역폭 ÷ 모델 바이트를 절대 넘지 못합니다 — 40GB Q4 70B 모델이면 소프트웨어 들어가기도 전에 DGX Spark 는 273/40 ≈ 7 tok/s, M3 Ultra 는 819/40 ≈ 20 tok/s 근처가 상한입니다. Spark 의 페타FLOP 은 prefill·배칭·파인튜닝에서 힘을 쓰고, 정확히 그 용도로 엔비디아가 만든 물건입니다; 큰 모델과 대화하려고 사는 것은 축을 잘못 고른 구매입니다. 맥의 512GB @ 819GB/s 가 대화형 추론 머신이고, 그 대가는 CUDA — vLLM, TensorRT, 대부분의 학습 레시피 — 를 떠나 MLX 와 llama.cpp 로 가는 것입니다.
클라우드가 둘 모두의 정직한 벤치마크입니다. 약 4천 달러면 온디맨드 H100 약 1,600시간 — 하루 8시간씩 1년 — 이고, 서버리스 토큰 과금(70B 급이 백만 토큰당 1달러 미만)은 사용이 들쭉날쭉할수록 손익분기를 더 밀어냅니다. 경험칙: 실험하는 동안은 빌리고(RunPod/Vast/Lambda 는 시간 단위, Together/Fireworks 는 토큰 단위, Modal 은 잡 단위, HF 엔드포인트는 매니지드 배포), 클라우드가 팔 수 없는 두 가지 — 방을 떠나면 안 되는 데이터, 하루 대부분 도는 머신 — 를 위해서만 하드웨어를 삽니다.
그래서 구매 결정은 둘이 아니라 세 개의 제품입니다. 큰 모델과의 대화형 채팅 → 대역폭(맥). CUDA 실험·배치 서빙·LoRA 학습 → Spark, 더 정직하게는 빌린 H100. 나머지 들쭉날쭉한 전부 → 클라우드, PoC 의 원장이 증거. sub-2bit-local-llm 은 같은 법칙의 반대편입니다 — 양자화는 분모의 모델 바이트를 줄이므로 모든 로컬 박스에서 2비트 기법이 FLOPs 보다 중요해집니다 — 그리고 huggingface-is-a-package-manager 가 이 카드의 파이프라인이 달리는 유통 레일입니다.
동작 방식
박스 셋 (2026년 초 시세 — 대략치로 볼 것)
DGX Spark
맥 스튜디오 M4 Max 128GB
맥 스튜디오 M3 Ultra 512GB
가격
~$4,000
~$3,700
~$9,500
통합 메모리
128GB
128GB
512GB
메모리 대역폭
273GB/s
~546GB/s
~819GB/s
연산
~1 PFLOP FP4, CUDA
Metal/MLX
Metal/MLX
만들어진 용도
prefill·배칭·파인튜닝·CUDA 개발
중형 채팅, 개발 박스
대형 모델 대화형 추론
편하게 도는 최대 Q4 모델
~70B (2대 연결 시 ~200B)
~70B
~400-670B 급
법칙 적용 — 이론적 디코드 상한 (Q4 가중치)
모델 (Q4 바이트)
Spark 273GB/s
M4 Max 546GB/s
M3 Ultra 819GB/s
8B (~5GB)
~55 tok/s
~109 tok/s
~164 tok/s
70B (~40GB)
~7 tok/s
~14 tok/s
~20 tok/s
405B (~230GB)
안 들어감 (2대면 가능)
안 들어감
~3.6 tok/s
실측은 상한 아래에 옵니다 — 얼마나 아래인지 스택별로 재는 것이 PoC 의 일입니다.
대신 빌리는 메뉴
서비스
단위
대략 가격
용도
RunPod / Vast.ai
GPU-시간
H100 ~$2-3/h, 스팟은 더 쌈
실험, LoRA 런
Lambda
GPU-시간
H100 ~$2.5-3/h
같은 용도, 더 매니지드
Together / Fireworks
토큰당
70B 급 < $1/1M 토큰
들쭉날쭉한 추론, 운영 제로
Modal
잡-초당
실행한 만큼
배치 파이프라인
HF Inference Endpoints
인스턴스-시간
매니지드 배포
데모, 소규모 프로덕션
손익분기, 정직하게
$4,000 ÷ $2.5/h ≈ H100 1,600시간 — 박스가 더 싸지려면 하루 8시간씩 1년.
서버리스는 채팅에서 더 불리하게 만듭니다: $1/1M 토큰이면 $4,000 은 약 40억 토큰.
수학을 뒤집는 것: 데이터가 방을 못 떠나는 요건, 거의 24/7 도는 머신, 실험마다 드는 클라우드 셋업 마찰의 미집계 비용.
전기료는 실재하지만 부차적: ~200-300W × 하루 8시간 ≈ 월 $10-15 — 자본 지출이 지배합니다.