Recursive Flint hardware requirements: VRAM, GPU, Mac and RAM
- Page updated
- Sources checked
- GGUF sizes and headers checked October 23, 2026
- Capacity estimates, labeled
- Jump to the checker ↓
Recursive Flint is Recursive's open-weight coding model for local agents, released October 21, 2026. It is a text-only mixture of experts with 39.8B parameters, about 2.5B of them active per token, and 35 of its 49 layers see only the last 513 tokens (the current one and 512 before it), so its KV cache stays small even at its 262K context.
Short answer: with llama.cpp the 4-bit Q4_K_M (24.2 GB) needs about 27 GB in total at a 32K context (RigCheck estimate). By that estimate it fits a 32 GB card (RTX 5090) or a Mac with 36 GB or more, while a 24 GB card (RTX 3090, 4090) runs it with 10 of its 49 layers in system RAM, which is slower. Recursive asks for more: a Mac with at least 48 GB for its own Q4_1 file, and at least 48 GB of GPU memory for its NVFP4 file; its commands use the full 262K context. Without a GPU, 48 GB of RAM holds Q6_K. Ollama's flint is a 23 GB download.
Can my hardware run Recursive Flint?
Open in a full page ↗Loading private checker…
RigCheck allocation estimate. Input embeddings stay in system RAM even when all decoder layers fit on the GPU. Their per-format sizes come from the GGUF headers of the linked files (read October 23, 2026); Recursive's Q4_1 file stores them as F32 (1.2 GB), its NVFP4 file as BF16 (0.6 GB), and LM Studio's files in 4 to 8 bits. Flint has a separate output head, which sits on the last GPU with the output layer; compute buffers sit on the first. We add a RigCheck allowance of 0.5 GB for host runtime/staging buffers, separate from the 8 GB OS reserve. Decoder weights are placed per layer from each file's own block sizes in its GGUF header (the two leading dense layers are much lighter than the 47 mixture-of-experts layers). Every file has 49 GGUF blocks and no MTP block, so full offload is -ngl 50. Commands disable automatic fitting with --fit off and pin decoder layers and the output layer with -ngl, using --tensor-split for multiple cards; they add flash attention, the chat template and Recursive's recommended sampling settings as its own commands do, and --cache-ram 0 as on Recursive's Q4_1 card, because llama-server otherwise keeps up to 8 GiB of prompt cache in host memory, which these estimates do not count. This is a mixture-of-experts model: keeping only the expert weights in system RAM (--n-cpu-moe) is another split, whose memory and speed this checker does not estimate. Actual tensor placement and buffer peaks can still differ; confirm runtime allocation before filling memory.
- Developer
- Recursive Official
- Params
- 39.8B total, about 2.5B active per token Official
- Context
- 262,144 tokens Official
- Input
- text only Official
- License
- Apache 2.0 Official
- KV cache
- 28 KiB per token at f16 RigCheck calculation
- llama.cpp
- Recursive publishes GGUF files for llama.cpp Official
- Ollama
- Ollama has flint Official
How much VRAM does Recursive Flint need?
The GGUF files as Hugging Face lists them (decimal GB, read October 23, 2026), and the total memory each needs at a 32K context with an f16 KV cache (RigCheck estimate). The official weights are BF16, about 80 GB in safetensors.
| File | File size | Needs at 32K | Source |
|---|---|---|---|
| Q8_0 | 42.4 GB | 45.2 GB | LM Studio |
| Q6_K | 32.7 GB | 35.5 GB | LM Studio |
| Q4_1 (official INT4) | 26.0 GB | 28.8 GB | Recursive |
| Q4_K_M | 24.2 GB | 27.0 GB | LM Studio |
| NVFP4 (official) | 22.9 GB | 25.7 GB | Recursive |
Recursive's Q4_1 file holds the trained INT4 weights of its MLX build in a GGUF, with the embeddings kept in F32, which Recursive says makes it larger than its MLX INT4 build. It is also larger than Q4_K_M: by the GGUF headers, Q4_1 uses more bytes per weight and its F32 embeddings are 1.2 GB against 0.2 GB. Recursive also publishes Flint INT4 for MLX (about 22.6 GB of weights), used by its own rec engine on Apple Silicon; this checker does not estimate MLX memory. Ollama's flint package is 23 GB; it also lists q4_1 (26 GB), NVFP4 and QAT-INT4 (23 GB each) and MLX BF16 (80 GB) tags.
What hardware can run Recursive Flint?
RigCheck estimate at a 32K context with an f16 KV cache, from the file sizes above and the assumptions under the checker. "Largest" means the largest of the checker's five files.
| Hardware | Largest file that fits fully | With layers in system RAM (slower) |
|---|---|---|
| No GPU + 32 GB RAM | none | not applicable (no GPU) |
| No GPU + 64 GB RAM | Q8_0 (all in RAM, CPU only) | not applicable (no GPU) |
| RTX 4060 (8 GB) + 32 GB RAM | none | Q4_1 (10 of 49 layers on the GPU, 22 GB in RAM) |
| RTX 3060 (12 GB) + 32 GB RAM | none | Q4_1 (17 of 49 layers on the GPU, 18 GB in RAM) |
| RTX 5060 Ti (16 GB) + 32 GB RAM | none | Q6_K (18 of 49 layers on the GPU, 21 GB in RAM) |
| RX 9070 XT (16 GB) + 32 GB RAM | none | Q6_K (18 of 49 layers on the GPU, 21 GB in RAM) |
| RTX 4090 (24 GB) + 32 GB RAM | none | Q8_0 (22 of 49 layers on the GPU, 24 GB in RAM) |
| RX 7900 XTX (24 GB) + 32 GB RAM | none | Q8_0 (22 of 49 layers on the GPU, 24 GB in RAM) |
| RTX 5090 (32 GB) + 32 GB RAM | Q4_1 | Q8_0 (30 of 49 layers on the GPU, 16 GB in RAM) |
| Mac, 32 GB unified | none | not applicable (unified memory) |
| Mac, 36 GB unified | Q4_K_M | not applicable (unified memory) |
| Mac, 48 GB unified | Q6_K | not applicable (unified memory) |
| Mac, 64 GB unified | Q8_0 | not applicable (unified memory) |
| NVIDIA RTX Spark, 64 GB unified | Q8_0 | not applicable (unified memory) |
Capacity only, not tested setups. The KV cache is small for a model of this size (1.0 GB at 32K, 3.8 GB at 128K, 7.6 GB at the 256K maximum), because only 14 of the 49 layers keep the whole context. At the full 262K context, Q4_K_M needs about 34 GB and Recursive's Q4_1 about 35 GB by our estimate, under the 48 GB Recursive asks for. A fit here below 48 GB is RigCheck's capacity estimate, not Recursive's requirement.
Measured Recursive Flint on your own hardware, or tried and it failed? Send us the numbers: paste the benchmark output or log into the form (or email it). After checking it we add it to this page, labeled as a community report and shared under CC BY 4.0.
Recursive Flint specs
| Parameters | 39.8B total, about 2.5B active per token (including the output head); 256 routed experts per MoE layer, 6 used per token, plus an always-active shared expert Model card |
|---|---|
| Architecture | 49 layers: 2 dense layers, then 47 mixture-of-experts layers; 35 sliding-window attention layers (513 tokens) and 14 full-attention layers; text only Model card |
| Context length | 262,144 tokens, prompt and output together Model card |
| KV cache | 28 KiB per token at f16 on the 14 full-attention layers (4 KV heads × 128 dims each), plus a fixed window cache on the 35 sliding layers: 1.0 GB at 32K, 7.6 GB at 256K RigCheck calculation |
| Input | text only; supports reasoning and multi-turn tool use Model card |
| License | Apache 2.0 License |
| Runtimes | Recursive publishes GGUF files for llama.cpp (a release with Flint support: b11803 or later), MLX INT4 weights for its own rec engine, and an SGLang kit for one B300 or H200 data-center GPU; Ollama has flint, and LM Studio publishes community GGUF files (checked October 23, 2026) |
FAQ
How much VRAM does Recursive Flint need?
By our estimate about 27 GB at a 32K context for the 4-bit Q4_K_M (24.2 GB file), and about 26 GB for Recursive's NVFP4 file (22.9 GB), so a 32 GB card holds either by our estimate (for NVFP4 that is capacity only: Recursive's tested list does not include 32 GB cards such as the RTX 5090). Recursive itself recommends at least 48 GB of GPU memory for its NVFP4 file (its command uses the full 262K context); our estimate for that file at 262K is about 32 GB.
Can Recursive Flint run on a 24 GB GPU like the RTX 3090 or 4090?
Only partly on the GPU, by our estimate: none of the five files fits fully at a 32K context. Q4_K_M runs with 10 of its 49 layers in system RAM, which is slower. Recursive's smaller NVFP4 file would keep 7 layers in RAM, but that is capacity only: Recursive lists only B300, RTX PRO 6000 Blackwell, RTX Spark and DGX Spark as tested for it, and an RTX 3090 or 4090 is not on that list, so the checker gives no command for it there. The 4-bit files themselves are 22.9 to 26.0 GB, so a shorter context does not change that much.
Can Recursive Flint run on a 16 GB or smaller GPU?
With enough system RAM, yes, but much of the model then runs from RAM: on a 16 GB card Q4_K_M keeps 25 of its 49 layers in system RAM at 32K (about 13 GB of RAM in all), by our estimate. On 8 GB or 12 GB cards the GPU holds only a small part of the model.
Can I run Recursive Flint on a Mac?
Yes, with 36 GB or more by our estimate: a 36 GB Mac holds Q4_K_M at a 32K context and a 48 GB Mac holds Q6_K; 32 GB Macs and smaller hold none of these files. That is below what Recursive asks for: its own Q4_1 GGUF for llama.cpp with Metal requires a Mac with at least 48 GB of unified memory, and its rec engine needs an M4 Pro, M5 Pro or M5 Max with at least 48 GB. Recursive says Flint generates more than 125 tokens per second on an M4 Pro MacBook Pro with its optimized engine at short contexts; that is its own figure for that machine and engine, not an estimate for other Macs; by Recursive's own comparison, llama.cpp is 1.4 to 2.6 times slower than rec on an M4 Pro.
Can Recursive Flint run on an NVIDIA RTX Spark or DGX Spark?
Yes: Recursive tested its NVFP4 GGUF with llama.cpp on RTX Spark and DGX Spark, and by our estimate a 64 GB RTX Spark holds even the 8-bit Q8_0 at a 32K context. Recursive says Flint generates more than 150 tokens per second on a 64 GB RTX Spark with its own optimized inference engine (unnamed; not the llama.cpp setup checked here) at short contexts. Recursive publishes no llama.cpp speed for it.
Can I run Recursive Flint without a GPU?
Yes, with llama.cpp's CPU build and enough RAM: by our estimate 48 GB of RAM holds Q6_K at a 32K context and 64 GB holds Q8_0; with 32 GB none of the files fits after the 8 GB we keep for the OS. We found no published CPU speed.
Is Recursive Flint on Ollama?
Yes: ollama run flint downloads a 23 GB package, and Ollama lists the model's context window as 256K. Ollama also lists q4_1 (26 GB), NVFP4 and QAT-INT4 (23 GB each) and MLX BF16 (80 GB) tags (checked October 23, 2026).
Does llama.cpp support Recursive Flint?
Yes, from release b11803: that is the first llama.cpp release with the flint architecture, its model code and its tokenizer (checked October 23, 2026). Recursive's GGUF cards ask for "a release with Flint support" and run llama-server with --jinja, flash attention and the full 262,144-token context.
Sources
- Hugging Face: RecursiveSI/flint (model card, config.json, Apache 2.0 license, file sizes) and Recursive's release post (speeds on M4 Pro and RTX Spark)
- Hugging Face: RecursiveSI/flint-int4-gguf (official Q4_1 GGUF for Apple Silicon: size, header, 48 GB requirement, llama.cpp command)
- Hugging Face: RecursiveSI/flint-nvfp4-gguf (official NVFP4 GGUF for NVIDIA: size, header, tested hardware, 48 GB recommendation)
- Hugging Face: lmstudio-community/flint-GGUF (Q4_K_M, Q6_K and Q8_0 sizes and headers)
- Ollama library: flint tags and Ollama's GPU support list (checked October 23, 2026)
- Recursive's rec engine (requirements) and RecursiveSI/flint-int4 (MLX INT4 weights)
- llama.cpp: src/llama-arch.cpp (the flint architecture, from release b11803), src/models/flint.cpp (sliding-window KV cache), src/llama-kv-cache-iswa.cpp and tools/server/README.md
- Usable-memory reserves, buffers and the offload model are RigCheck assumptions, stated under the checker.