Recursive has released Flint, a 40-billion-parameter coding model whose quantized weights occupy about 23GB.[1][2] The weights are available now under Apache 2.0, with official packages for Apple Silicon and Nvidia hardware.[1][6][7] For people with a 48GB Mac or GPU, that makes Flint a serious local alternative to metered coding services.[4] The catch is that a 23GB model file does not make this a comfortable fit for a 24GB graphics card.[7]
This is a real release rather than a promise.[1] HighVRAM verified that the base BF16 checkpoint and inference code are public.[2][3] The 22.6GB MLX INT4 weights and 22.9GB NVFP4 GGUF are public too.[6][7] The base model card also lists a 262,144-token context configuration, text-only input, tool calling and an Apache 2.0 license.[2]
Why 40B can still be fast
Flint is a mixture-of-experts model.[2] It stores 39.8 billion parameters but activates roughly 2.5 billion for each token, including the output head.[2] The full weight set still has to fit in memory, but only a fraction does the arithmetic on each pass.[2] That is why a roughly 40B model can behave more like a small model in generation speed without becoming a small model on disk.[1][2]
Recursive says its own `rec` engine produces more than 125 tokens per second on an M4 Pro MacBook Pro and more than 150 tokens per second on a 64GB RTX Spark at short context lengths.[1] Those are company measurements, not HighVRAM tests.[1] The open-source engine’s repository also claims 1.4 to 2.6 times the token throughput of llama.cpp on a 48GB M4 Pro across prompts from 1,000 to 252,000 tokens.[3]
There is one useful independent check. WIRED’s Will Knight ran Flint on a Mac with 48GB of memory, used it to build a command-line to-do list, a research tool and a simple website, and described it as fast and capable.[5] He wrote that it completed each of those coding requests successfully.[5] That is encouraging hands-on reporting, but it is one reviewer’s workload, not a reproducible benchmark suite.
Recursive’s benchmark table puts the BF16 model at 74.2% on SWE-bench Verified, 54.9% on Terminal-Bench 2.1 and 89.7% on SWE-bench Pro v2.[2] Treat those as vendor results.[2] The model card warns that evaluation setups differ, and Recursive itself says Flint may need more explicit, smaller steps than large paid coding assistants.[2][4]
The 24GB problem
The Nvidia package is a 22.9GB file.[7] In the binary units used for GPU memory, that is about 21.33GiB, leaving only 2.67GiB on a nominal 24GiB card before the context cache, runtime workspace, graphics use or anything else asks for memory.[7]
HighVRAM calculated the cache from Flint’s published architecture and the FP16 key/value cache used in its official llama.cpp command.[2][7] At 8,192 tokens, the cache is about 0.25GiB.[2][7] At 32,768 tokens it is about 0.91GiB.[2][7] At the documented 262,144-token limit, it rises to roughly 7.03GiB.[2][7] Those estimates include the model’s 14 full-attention layers and fixed 513-token windows for its other 35 attention layers; they do not include allocator overhead or runtime scratch space.[2][7]
So a 24GB card might squeeze through a short-context experiment with careful settings, but it has almost no safety margin.[2][7] Recursive recommends at least 48GB of GPU or unified memory for the NVFP4 release.[7] I would not buy Flint on the assumption that an RTX 4090 or RTX 5090 will deliver the intended experience until someone publishes repeatable 24GB results.
The supported paths are less ambiguous:
– A Mac with an M4 Pro, M5 Pro or M5 Max and at least 48GB of unified memory can use `rec`; the repository asks for about 30GB of free storage and is optimized for one session at a time.[3] – A 48GB Nvidia GPU can run the official NVFP4 GGUF through a Flint-compatible llama.cpp build.[7] – The roughly 80GB BF16 checkpoint is aimed at an H200 or B300 through SGLang, which is server territory rather than a sensible home default.[2]
Recursive also says Flint works with Ollama, LM Studio, Unsloth and vLLM.[1] Availability is not the same as equal optimization, however. The headline speed figures come from `rec` on specific Macs and Recursive’s tuned Nvidia path, so a generic desktop wrapper may be slower.
Context, privacy and the sensible decision
There is a small documentation wrinkle. Recursive’s launch post says Flint supports up to 512,000 tokens but recommends staying within 256,000. The released model card and official Nvidia command use 262,144 tokens.[1][2][7] Buyers should plan around the documented 262K configuration, not the larger marketing ceiling. Long context also consumes memory and time; capacity does not guarantee that the model will use every old line of code well.
Running locally keeps prompts, source code and generated patches on the machine, avoiding per-token API charges and unnecessary uploads.[1][4] It does not make an autonomous coding agent harmless. Recursive’s model card says generated code and tool calls can be wrong, and that applications need their own permission boundaries.[2] Give the agent a disposable branch, tests and narrowly scoped credentials. Privacy is useful. Root access is still root access.
Flint looks worth trying now if you already own a supported 48GB Mac or Nvidia system and spend enough time coding to value local control. The weights, license and runtime are present, and the first independent hands-on report is positive.[1][2][5] If your best GPU has 24GB, wait for careful community measurements before spending money. The next evidence that matters is not another benchmark chart; it is sustained speed, code quality and failure rates on ordinary 24GB and 48GB machines.
Try it on your hardware? Share a measured result. If you are stuck, ask with your goal, current hardware and blocker. For future reporting, follow the weekly update by RSS.