Så här kör du GLM-5.3-Flash på en MacBook Pro: 2bit-Lite MLX Playbook

Att köra GLM-5.3-Flash på en MacBook Pro innebär exakt en maskin: en 128 GB M4/M5 Max MacBook Pro som kör 2bit-lite-versionen av vår MLX-konvertering, med gränsen för macOS:s trådbundna minne höjd. Om din MacBook Pro har mindre än 128 GB — en 36 GB M4 Pro, en 48 GB M4 Max — är denna handbok inte för dig; hoppa till sista avsnittet och dirigera om till den hostade z-ai/glm-5.3-flash API:et istället. GLM-5.3-Flash (vikter på zai-org/GLM-5.3-Flash) är Z.ai:s 320-miljarder-parameter Mixture-of-Experts-modell med 18B aktiva per token — släppt 26 augusti 2026, den första nativt multimodala GLM-​5 — och även den minsta versionen av vår MLX-port behöver ~102 GB vikter och ~112 GB minne. Det är hela marknaden, och vi tänker inte mjuka upp det.

Detta är förstapartsdokumentation, inte en lanseringstext: vikterna nedan är OrcaRouters egen build (orcarouter/GLM-5.3-Flash-MLX, MIT), framställd med vår kalibreringsfria OrcaSAQ-kvantiseringsmetod. Vi släppte den den 26 augusti och korrigerade kursen offentligt dagen därpå, eftersom det ursprungliga kvantiseringsintervallet inte gjorde MacBook Pro-användning praktisk för de flesta – den vanliga 2-bit-builden behövde fortfarande ~160 GB, vilket ingen bärbar dator har. Den 27 augusti byggde vi om den minsta varianten som 2bit-lite specifikt för att passa en 128 GB MacBook Pro, och den här texten är den ärliga redogörelsen för vad det ger dig och vad det kostar. Varje nummer märkt fältanteckning nedan mättes i vår verifieringskörning på en enda H200; ingenting här är en leverantörsbenchmark. Där vi upprepar communitypraxis – kommandot för trådbundet minne, mlx-vlm-versionering – märker vi det som sådant.

Vilken build passar vilken Mac (läs detta innan du laddar ner något)

De fem byggen i repot motsvarar var och en ett minsta RAM-värde. På en MacBook Pro har "vilket bygge" exakt ett svar — allt ovanför 2bit-lite är ett Mac Studio-samtal:

• 6-bit — ~296 GB vikter / ~320 GB RAM / nästan förlustfritt. Endast Mac Studio med 512 GB.

• 4-bit — ~204 GB / ~224 GB / vår rekommenderade standard. Mac Studio 256 GB. Detta är vad repo-roten speglar.

• 3-bit — ~184 GB / ~200 GB. Mac Studio 256 GB.

• 2-bit — ~145 GB / ~160 GB. Mac Studio 192 GB. Detta var den minsta builden vi släppte på dag ett, och det var missen.

• 2bit-lite — ~102 GB / ~112 GB. Den enda versionen som får plats på en 128 GB-maskin — en 128 GB M4/M5 Max MacBook Pro, eller en 128 GB Mac Studio eller Mac mini. Alla 128 GB Apple Silicon-bärbara datorer (M3 Max eller nyare) är samma sak, bara långsammare.

Fällan gömd i den stegen: README-filens standardkommando för nedladdning hämtar 4-bitarsbygget (~204 GB), vilket är rätt standard för en maskin med 256 GB och oanvändbart på en bärbar dator. Om du följer standardkommandot på en MacBook Pro får du en modell som inte kommer att allokera. 2bit-lite-sökvägen kräver en explicit --include, vilket behandlas nedan.

Det finns också en hård gräns som du kommer att stöta på innan matematiken ovan ens är tillämplig. macOS låter inte en process lägga beslag på hela det enhetliga minnet i en Mac med 128 GB; den förinställda GPU-användbara gränsen är ungefär 91–96 GB (framtagen genom reverse engineering av communityn och bekräftad i flera artiklar om stora modeller med MLX-installationer). Det är under de ~102 GB som vikterna ensamma kräver, så kommer inte ens 2bit-lite att laddas förrän du höjer gränsen för låst minne. Det steget är obligatoriskt, och det är avsnitt 4.

Installera mlx-vlm — och endast mlx-vlm

GLM-5.3-Flash är en vision-språkmodell, så den körs under mlx-vlm, inte mlx-lm. Detta är det vanligaste sättet som folk fastnar på, så säg det tidigt: mlx-lm är för textbaserade modeller; att köra en multimodala modell genom den ger ett förvirrande laddningsfel. Installera VLM-paketet i version 0.6.17 eller senare:

pip install -U "mlx-vlm>=0.6.17"

Versionslåsningen är inte dekoration. glm5_next — den hybrida sparse-plus-linear-attention-arkitekturen bakom GLM-5.3-Flash — landade i mlx-vlm först samma dag som modellen släpptes (26 augusti 2026), och äldre versioner än så kommer inte att känna igen konfigurationen. Arkitekturen är viktig av en andra anledning: det här är en helt ny topologi, och de första portningarna hade verkliga korrekthetsbuggar som flytande utdata inte skulle avslöja. En community-runtime-granskning av den tidiga glm5_next-MLX-vägen hittade och åtgärdade fyra av dem — en ej applicerad SwiGLU-clamp på varje FFN-block, manifold-begränsade hyper-connection-tensorer typomvandlade till fel dtype (vilket tyst korrumperade attention-mixningsmatrisen), två epsilon-avvikelser i attention-normerna, och bf16-routerlogiter där referensen använder float32. Efter korrigeringarna stämde numeriken överens med referensen till ungefär 1e-7. Slutsatsen för dig: håll mlx-vlm uppdaterat och betrakta den allra första releasen av varje ny arkitekturportning med misstänksamhet.

Ladda ner vikterna: uteslutningsflaggorna och inkluderingen du faktiskt behöver.

Reporoten speglar 4-bit-bygget, och alla fem varianterna levereras som undermappar. Standardkommandot hämtar roten och använder --exclude så att ingen av de fem variantmapparna (som tillsammans är i storleksordningen 800 GB) följer med:

hf download orcarouter/GLM-5.3-Flash-MLX --local-dir ./GLM-5.3-Flash-MLX --exclude "2bit-lite/*" "2-bit/*" "3-bit/*" "4-bit/*" "6-bit/*"

På en MacBook Pro är det kommandot fel för dig — det ger dig 4-bitarsroten. För en 128 GB-laptop, hämta endast undermappen 2bit-lite:

hf download orcarouter/GLM-5.3-Flash-MLX --include "2bit-lite/*" --local-dir ./GLM-5.3-Flash-MLX

Det är den ~102 GB stora nedladdningen, och den är fristående — 2bit-lite/-mappen innehåller sin egen config.json, så du pekar generatorn direkt på den. Om hf inte finns på din PATH, installera det: pip install -U huggingface_hub. Innan du börjar, kontrollera att du har ~110 GB ledigt diskutrymme och att din Mac:s lagringsutrymme inte är nere på de sista 100 GB lediga — MLX minnesmappar vikterna, och en nästan full SSD är hur dessa installationer dör mitt i nedladdningen.

Höj gränsen för wired-minne — steget som alla glömmer.

Detta är det avgörande steget på en 128 GB MacBook Pro, och README-kortet antar att du kan det snarare än att tala om kommandot. Standardtaket för Metal-arbetsuppsättningen på en 128 GB Mac är ungefär 91–96 GB, vilket är under de ~102 GB som 2bit-lite-vikterna kräver — så utan detta steg misslyckas modellen med att allokera och inläsningen dör. Den communitystandardiserade lösningen är en sysctl som höjer taket för GPU:ns wired-minne i megabyte:

sudo sysctl iogpu.wired_limit_mb=114688

Det sätter ett tak på ~112 GB, vilket lämnar ungefär 14 GB som OS-reserv. På maskiner med 128 GB varierar community-värden i praktiken från ~114688 (112 GB) upp till ~122880 (120 GB); maxa inte — macOS behöver utrymme, annars hackar fönsterservern och systemet rycker vid minnestryck. Efter att du har ställt in det, ladda modellen och håll ett öga på Activity Monitor: om minnestrycket blir gult, dra ner på siffran.

Två praktiska anmärkningar, båda från communitypraxis snarare än våra fältanteckningar. För det första återställs sysctl vid omstart och gäller för den terminalsession där du ställer in den, så planera att köra den igen (eller skripta den via en LaunchAgent) — att glömma bort den efter en omstart är det klassiska "det funkade igår"-felet. För det andra exponerar MLX också ett processinternt reglage, mlx.core.metal.set_wired_limit(bytes), på macOS 15.0 och nyare; den måste ligga under sysctl-taket, och det är det mer portabla alternativet om du skriptar en notebook. Vilken du än använder är effekten densamma: utan den körs ingenting här.

Kör det: text, bild och Python API

Med vikterna på plats och gränsen höjd är generation ett enda kommando. Text:

python -m mlx_vlm.generate --model ./GLM-5.3-Flash-MLX/2bit-lite --prompt "Förklara kvantinträngning i en mening." --max-tokens 256

Bildinmatning fungerar på samma sätt med en --image flagga — det är här den multimodala modellen gör skäl för sig på en bärbar dator, eftersom vision-tornet behåller högre precision i OrcaSAQ-layouten:

python -m mlx_vlm.generate --model ./GLM-5.3-Flash-MLX/2bit-lite --image photo.jpg --prompt "Beskriv den här bilden." --max-tokens 256

För ett skript har Python-API:et samma utformning som mlx-vlm-användare känner till:

from mlx_vlm import load, generate from mlx_vlm.prompt_utils import apply_chat_template model, processor = load("./GLM-5.3-Flash-MLX/2bit-lite") prompt = apply_chat_template(processor, model.config, "Beskriv den här bilden.", num_images=1) print(generate(model, processor, prompt, ["photo.jpg"], max_tokens=256, verbose=True))

Håll --max-tokens måttligt. I vår H200-fältanteckningskörning ligger 2bit-lite på ungefär 10 tok/s, så ett svar på 1 024 tokens är redan en väntan på två minuter – och långa utdata är där KV-budgeten och kvalitetskollapsen biter (nedan). På en laptop bör du förvänta dig att det känns långsammare, inte snabbare, tills det finns en uppmätt siffra.

Vilken kvalitet du faktiskt får (den uppmätta stegen)

Här är den ärliga delen av spelboken, och vi tänker inte skönmåla den. OrcaSAQ degraderas smidigt ner till 3 bitar, sedan ökar kostnaden snabbt. Jämfört med FP8-referensen (perplexitet 2,7797):

• 6-bit — perplexity 2,7864 (+0,24 %), top-1-tokenöverensstämmelse 97,76 %. Nästan förlustfri, som utlovat.

• 4-bit — perplexity 2,8620 (+2,96 %), top-1 96,13 %. Rekommenderad standard.

• 3-bit — perplexity 3.0566 (+9.96%), top-1 92.06%. Aggressiv men användbar.

• 2-bit — perplexity 4.3622 (+56,9 %), top-1 86,56 %. En verklig kostnad.

• 2bit-lite — perplexity 6.7018 (+141%), top-1 77.19%. Den minsta versionen och den enda som får plats i en MacBook Pro.

Dessa är uppmätta siffror från vår egen konverteringspipeline. 2bit-lite innebär en 141% försämring av perplexiteten och en top-1-tokenöverensstämmelse under 78% — du kör en märkbart försämrad modell, och felfallen nedan är vad den försämringen ser ut i praktiken. Det är en lysande demo och en hygglig kortformsassistent; det är inte en ersättning för fullprecisionsmodellen.

När det gäller hastighet är vi skyldiga dig samma ärlighet. Den publicerade fältnoteringen är H200: ~10 tok/s, stabil multi-turn, vardaglig Q&A och kortare texter fungerar bra. Vi har ännu ingen uppmätt siffra för 2bit-lite på MacBook Pro, och vi tänker inte hitta på en — genomströmningen på Apple Silicon här beror på minnesbandbredd, termik och MLX-kärntäckning för den hybrida attention-mekanismen, varav inget vi har mätt för denna build på denna bärbara dator. Den närmaste publicerade Apple Silicon-datapunkten vi kan hänvisa dig till är en oberoende ~450 tok/s för en 4-bitars GLM-5.3-Flash-build på en 512 GB Mac under en annan MLX-runtime — en annan build, en annan precision och en stationär dator, så se det inte som din siffra heller. Planera för långsamhet; bli glatt överraskad om det inte blir så.

KV cache och lång kontext: tänk på marginalen

GLM-5.3-Flashannonserar ett kontextfönster på 1M token. Den siffran är irrelevant på den här hårdvaran, och en guide som låtsas något annat skulle göra dig en björntjänst. Fältanteckningen är en rad: ge körtiden tillräckligt med KV-budget för din mållängd. På en enda H200 lämnar 2bit-lite ungefär 39 GB utrymme för KV-cache efter att vikterna har laddats. På en 128 GB MacBook Pro är räkningen hårdare: ~102 GB vikter mot ett tak på ~112 GB lämnar i storleksordningen 26 GB innan macOS:s egen arbetsyta – och de hybrida linjära uppmärksamhetslagren gör modellens KV-fotavtryck litet jämfört med en tät modell av den här storleken, men det växer fortfarande linjärt med kontexten.

Råd från den bredare communityn på serveringssidan bekräftar poängen: en konfiguration som laddar bra i en 8K-kontext kan få slut på minne vid 128K. På laptopen, håll kontexterna korta — ett par tusen tokens av frågor och svar eller en enda bild — och försök inte mata den med en bok. I samma stund som en arbetsbelastning verkligen behöver lång kontext befinner du dig i den sista delen av den här texten.

Lång kodgenerering är inte tillförlitlig vid 2bit-lite (läs detta två gånger)

Detta är det avsnitt som en instruktion som döljer sina felsätt vore värdelös utan, så det får en egen rubrik. H200-fältanteckningarna är entydiga: vardagliga frågor och svar samt kort text fungerar bra, medan lång kodgenerering inte är tillförlitlig vid denna precision. Tre felsätt reproducerades vid vår verifieringskörning:

• Repetitionsloopar — modellen börjar upprepa samma rader eller block i stället för att göra framsteg, vanligtvis efter några hundra token.

• Saknad limkod — importer, kopplingar och felhantering utelämnades tyst. Den genererade funktionen ser korrekt ut i isolering och körs inte, eftersom den kringliggande stödstrukturen helt enkelt saknas.

• Omskrivningsinstabilitet— i stället för en minimal redigering skriver modellen om stora delar av en fil, och efterföljande turer motsäger varandras utdata.

Dessa är reproducerbara på 2bit-lite, och de är precis de saker som en 77% top-1-överensstämmelse förutsäger. Vad utövare som har kvar laptopbygget faktiskt gör:

• Använd det till förklaring, sammanfattning, frågor och svar samt bildförståelse — kortformat arbete där det verkligen är bra.

• Om du måste be om kod, be om en liten funktion i taget med en tydlig signatur, och verifiera varje funktion innan du går vidare. Ge den inte en hel fil och be om en funktion.

• För allt som är långt — en hel modul, en refaktorering, en lång agentsession — dirigera till API:et med full precision. Det är inte en kringgående lösning; det är rätt arkitektur, och det är det sista avsnittet.

När du inte ska göra detta alls: anropa z-ai/glm-5.3-flash istället

Den ärliga beslutsregeln: kör 2bit-lite på en 128 GB M4/M5 Max MacBook Pro endast när du specifikt vill ha en 320B multimodal modell på en laptop du kan bära med dig — offline frågor och svar, privata dokument, bildförståelse utan att något lämnar maskinen. Välj API:t för allt annat:

• Alla MacBook Pro under 128 GB — det finns ingen build för dig. Försök inte att ladda den; använd API:t.

• Generering av lång kod eller resonemang med lång kontext — 2bit-lite misslyckas just med detta, konsekvent. Använd API:et.

• Kvalitetskänsligt arbete — 77.19% top-1-överensstämmelse och +141% perplexity är en verklig nedgång, inte ett avrundningsfel. Använd API:t.

• Garanterat genomflöde eller förutsägbar latens — det finns ännu ingen uppmätt laptopsiffra, och fältnoteringen är 10 tok/s. Använd API:t.

Den värdbaserade modellen är z-ai/glm-5.3-flash, som körs med full precision på OrcaRouter till Z.ai:s nuvarande prissättning — 0,07 USD per miljon input-tokens och 0,25 USD per miljon output-tokens vid skrivande stund (introduktionspris; Z.ai:s publicerade lista är 0,15 / 0,50 USD). Det är leverantörens rapporterade pris, och det förs vidare med 0 % påslag, så en prissänkning från Z.ai syns hos oss samma dag. Du får en API-nyckel som även når de övriga 200+ modellerna vi dirigerar, och automatisk failover innebär att ett experiment med den här nya modellen inte satsar din produktionsväg på en enda leverantör. På samma tid som det tar att ladda ner 102 GB och vänta ut den första kalla genereringen har API:et redan besvarat en veckas frågor — och det besvarar dem med full precision.

Lokal inferens är värd det när anledningen är lokal — integritet, offlinearbete, inga anropsbegränsningar, en demo som körs på batteri. Det är inte värt det av något annat skäl, vare sig man räknar på kostnad eller kvalitet, och det är inte alls värt det på en maskin med mindre än 128 GB.

FAQ

Kan en 64 GB eller 96 GB Mac köra GLM-5.3-Flash lokalt? Nej. Den minsta versionen, 2bit-lite, kräver minst cirka 112 GB efter macOS-overhead, och även en 128 GB-maskin måste höja gränsen för wired memory för att kunna läsa in den. Om din Mac har under 128 GB finns ingen lokal väg; dirigera z-ai/glm-5.3-flash via API:t istället.

Jag installerade mlx-vlm och modellen kan inte laddas — vad är felet? De två vanligaste orsakerna, i ordning: en version äldre än 0.6.17, som föregår stödet för glm5_next och inte känner igen arkitekturen; samt att gränsen för trådat minne inte har höjts, eftersom bygget på ~102 GB inte kan allokera under det förinställda Metal-taket på ~91–96 GB på en 128 GB Mac. Åtgärda båda (uppgradera paketet, kör sysctl) så läses modellen in.

Är det lokala 2bit-lite-bygget samma modell som z-ai/glm-5.3-flash API:et? Samma underliggande GLM-5.3-Flash-vikter, men inte samma kvalitet. 2bit-lite är en 2-bitars kvantisering med 77.19 % top-1-tokenöverensstämmelse mot FP8-referensen, och lång kodgenerering är opålitlig. API:et levererar full precision. De är utbytbara endast för kortfattat, kvalitetstolerant arbete.

30-sekundersversionen

En maskin, en build, en obligatorisk sysctl. Om du har en 128 GB M4/M5 Max MacBook Pro: installera mlx-vlm>=0.6.17, ladda bara ner 2bit-lite/ (~102 GB), höj gränsen för wired-minne med sudo sysctl iogpu.wired_limit_mb=114688, och kör mlx_vlm.generate — för frågor och svar, kort text och bilder. Acceptera att generering av lång kod inte är tillförlitlig vid denna precision, att det ännu inte finns någon uppmätt genomströmning för bärbara datorer, och att en 128 GB Mac är golvet, inte standarden. Om något av dessa förbehåll är en dealbreaker — eller om din Mac har under 128 GB — så är samma modell i full precision bara ett API-anrop bort på z-ai/glm-5.3-flash.

Not on a 128 GB Mac? z-ai/glm-5.3-flash serves the same model at full precision on OrcaRouter — one API key, provider pricing passed through at 0% markup, and no 102 GB download.