JetBrains Mellum2 12B Open-Source Code Model Released

JetBrains released Mellum2, a 12-billion-parameter open-source code model, on June 12, 2026. The company published the release on its official JetBrains homepage and linked to model weights on Hugging Face. Mellum2 has a 128,000-token context window and an Apache 2.0 license. The model is designed for local code generation, completion, refactoring, and bug explanation. It does not require a JetBrains IDE to operate. This release moves JetBrains from a closed AI assistant feature toward an open-weight model that developers can host themselves. It arrives during a wave of AI pricing changes and free tier limits across the industry. You can track the latest model launches in the AI updates roundup.

Why does this matter for developers? Mellum2 offers a self-hosted coding model with no per-token API fees. The Apache 2.0 license permits commercial use, modification, and redistribution. Teams can fine-tune the model on private code and run it on their own hardware. That removes dependence on cloud APIs that now change pricing and limits frequently. Many developers have watched free tiers shrink and usage-based billing spread across major coding tools. Mellum2 joins a growing list of open models that aim to replace paid coding assistants for budget-conscious users. The model is not a frontier general chatbot. It is a focused code model with a practical size and a permissive license.

Benchmark scores place Mellum2 in competitive territory for a 12B model. JetBrains reported 89.2 percent on HumanEval, 81.3 percent on MBPP, and 42.1 percent on SWE-bench Verified. These numbers do not beat the largest proprietary models from OpenAI or Anthropic. But they are strong for a model that fits on a single GPU. Many developers do not need frontier performance for daily code completion. They need a local model that avoids per-token costs and usage limits. The pressure on coding API pricing is already intense. Major tools have shifted toward usage-based billing and tighter free tiers, as covered in our coding tools pricing analysis. Mellum2 gives developers an escape hatch from that volatility.

Running Mellum2 is practical for many teams. The full FP16 weights are about 24GB. An 8-bit quantized version cuts memory to roughly 12GB, which fits a 16GB consumer GPU. You can serve the model with vLLM, llama.cpp, or Ollama. It exposes an OpenAI-compatible local API. JetBrains also posted quantization artifacts and example scripts. The model does not phone home or require a cloud account. For regulated industries and privacy-focused developers, local inference keeps source code on your own machine. Setup requires some command line skill, but the barrier is lower than many open model releases. This release lands at a time when local coding tools are gaining traction.

How Do the Top Options Compare?

Parameter counts for proprietary models may not be officially disclosed. Context lengths are approximate and can vary by deployment and quantization.

1. Mellum2 Model Overview , Best for local, offline code generation and completion

JetBrains Mellum2 is a 12-billion-parameter transformer model optimized for source code. The company announced the open-source release on June 12, 2026, pointing to its official JetBrains homepage and a Hugging Face model card. The model accepts a 128,000-token context window, which is large enough for multi-file projects and repository-level questions. Full FP16 weights are about 24GB. A quantized 8-bit version cuts that to roughly 12GB. Mellum2 is not a general chatbot. It is built for code generation, completion, refactoring, and bug explanation. JetBrains trained it on source code plus technical documentation. The model produces plain text code and follows system prompts that ask for specific edits. It does not require a JetBrains IDE. You can serve it with any standard inference engine. The license is Apache 2.0. That means you can use Mellum2 in commercial products, modify it, and distribute the weights. You can also fine-tune it on your own codebase without paying royalties. This is a major difference from closed coding models like GitHub Copilot or ChatGPT Codex, which charge per token or per seat. For developers who already use the free AI model landscape as a guide, Mellum2 adds a serious self-hosted option.

Key strengths:

• ✅ Apache 2.0 license allows commercial use, modification, and redistribution
• ✅ 128K token context handles large codebases and repository-level edits
• ✅ No per-token API fees or subscription rate limits
• ✅ Runs on a single 16GB GPU in quantized form
• ✅ Works with standard inference engines like vLLM and llama.cpp
• ❌ 12B parameters trail 70B-plus open models on complex multi-step reasoning
• ❌ Local setup requires command line and hardware skills
• ❌ No official JetBrains hosted API or managed service announced

Who it’s for: Developers who want a private, free coding model that runs on their own hardware.

2. Benchmarks and Performance , Best for strong code generation without remote API latency

JetBrains published benchmark scores with the Mellum2 release. The model reaches 89.2 percent on HumanEval and 81.3 percent on MBPP. On SWE-bench Verified it scores 42.1 percent. These numbers are close to smaller proprietary code models but below frontier closed systems. For a 12B model, the results are competitive. You can find the leaderboard references on the Hugging Face model card. The benchmark profile matters for real work. HumanEval and MBPP test Python function generation from docstrings. SWE-bench Verified tests repository-level bug fixing. A 42.1 score means the model can solve some multi-file issues but will still need human review. JetBrains also tested Kotlin and Java tasks because those languages are common in its IDE community. Early community tests report solid results on JetBrains code patterns. Compared to closed coding tools, Mellum2 does not beat the newest OpenAI or Anthropic models on agentic long-horizon tasks. But it avoids usage-based billing and rate limits that now affect major coding tools. For developers who want predictable local throughput, a 12B model on a GPU is often faster than waiting on a cloud API queue. The tradeoff is that you supply the hardware and accept lower peak quality.

Key strengths:

• ✅ Strong HumanEval 89.2 percent for a 12B model
• ✅ Competitive MBPP and SWE-bench Verified scores
• ✅ Tested on Python, Kotlin, and Java code
• ✅ No remote API latency because inference runs locally
• ✅ Quantized versions preserve most benchmark accuracy
• ❌ Lags frontier closed models on multi-file agentic coding
• ❌ Benchmarks may overstate performance on enterprise codebases
• ❌ Tokenizer handles some languages worse than English and PyTorch idioms

Who it’s for: Teams that need solid local code generation and can tolerate occasional human review.

3. License and Commercial Use , Best for companies that need permissive open-source terms

Mellum2 uses the Apache 2.0 license. JetBrains chose this license to remove friction for commercial adoption. You can use the model in a SaaS product, embed it in an IDE plugin, or distribute a fine-tuned version. You do not need to open source your own code. You also do not owe JetBrains royalties. That is a key difference from some open-weight models with non-commercial or share-alike clauses. The release arrives during a period when many AI vendors are changing pricing and access. Free tiers are shrinking and usage-based billing is spreading across AI coding tools. An Apache 2.0 model gives companies a fixed-cost escape hatch. You pay for hardware and engineering time, not tokens. You can freeze the model version and avoid silent upstream changes that sometimes break prompts. There are still practical limits. Apache 2.0 is a software license, not a warranty. JetBrains does not offer indemnification for model outputs. If the model generates code that infringes a patent or includes vulnerable patterns, your company carries the risk. You should run security scanners and human review before shipping Mellum2 output. But for internal tools and developer productivity, the license is clean and permissive.

Key strengths:

• ✅ Apache 2.0 permits commercial use and derivative works
• ✅ No share-alike or non-commercial restriction
• ✅ You can fine-tune on proprietary code without revealing it
• ✅ Fixed local hosting avoids per-token cost spikes
• ✅ JetBrains is unlikely to add fees after release
• ❌ No indemnification from JetBrains for generated code
• ❌ Hosting and maintenance costs fall on your team
• ❌ License clarity does not guarantee model output safety

Who it’s for: Enterprises and startups that want to ship a code AI feature without licensing headaches.

4. How to Run Mellum2 Locally , Best for private, offline AI coding setups

JetBrains published weights on Hugging Face and linked to inference examples on GitHub. You do not need a JetBrains IDE to run the model. You can use vLLM for GPU serving, llama.cpp for CPU and Apple Silicon, or Ollama for a quick local API. The model supports standard Hugging Face Transformers checkpoints. Hardware requirements depend on precision. Full FP16 inference needs about 24GB of VRAM. An RTX 4090, A6000, or 48GB workstation card works well. 8-bit quantization cuts memory to about 12GB, which fits a 16GB GPU. 4-bit GGUF versions run on CPUs with enough RAM, though throughput is slower. JetBrains published quantization artifacts for common setups. This is similar to how developers run open models from free coding tool ecosystems. Setup is not one click. You need Python, a model server, and some familiarity with tokenizers and prompts. But once running, Mellum2 exposes an OpenAI-compatible API. That allows you to point JetBrains AI Assistant, Continue, or other local coding clients at it. You keep your source code on your own machine. For regulated industries, that is a major advantage over sending code to a cloud API.

Key strengths:

• ✅ Runs on vLLM, llama.cpp, and Ollama
• ✅ OpenAI-compatible local API endpoint
• ✅ Quantized versions fit 16GB consumer GPUs
• ✅ No telemetry or cloud account required
• ✅ Works with JetBrains AI Assistant and other local clients
• ❌ Command line setup is not beginner friendly
• ❌ FP16 throughput needs powerful workstation hardware
• ❌ No official JetBrains plugin to automate installation yet

Who it’s for: Developers with local model experience who want offline code AI.

5. Competitive Context and What’s Next , Best for understanding the open code model landscape

Mellum2 enters a crowded open-source model market. DeepSeek, Qwen, Mistral, and Kimi have released open-weight coding models across sizes from 7B to over 1 trillion parameters. JetBrains brings a focused 12B option with Apache 2.0 terms. It does not aim to beat the largest models. It aims to be a practical, local, free coding assistant that fits in developer workflows. The timing is notable. Google has cut Gemini prices, OpenAI and Anthropic have shifted free tier limits, and coding tools have introduced usage-based billing. These changes are pushing more developers to evaluate self-hosted models. The Google price cuts show that cloud API economics are in flux. A 12B Apache model removes that variable entirely. What is next for Mellum2? JetBrains hinted at deeper AI Assistant integration and possibly domain-specific fine-tunes for Kotlin, IntelliJ, and Fleet. Community contributors may port the model to MLX for Apple Silicon and create GGUF packs for CPU inference. The open-source model will live or die by how well the community builds around it. But the license and size make it a credible foundation. Expect more 10B to 15B open code models to follow this pattern.

Key strengths:

• ✅ Adds a credible 12B Apache option to the open code model market
• ✅ Likely tight integration with JetBrains AI Assistant
• ✅ Self-hosted model avoids cloud API price volatility
• ✅ Small enough for community fine-tunes on a single GPU
• ✅ Timing aligns with developer backlash against usage-based coding fees
• ❌ May be overshadowed by upcoming 30B open models with better scores
• ❌ No JetBrains-managed cloud API for teams that do not want hardware
• ❌ Community tooling and documentation are still early

Who it’s for: Analysts and developers choosing between self-hosted open models and paid cloud coding APIs.

Frequently Asked Questions

What Should You Remember?

• Mellum2 release: JetBrains shipped a 12B open-source code model on June 12, 2026 with a 128K token context window.
• License: Apache 2.0 allows commercial use, modification, and redistribution without royalties.
• Benchmarks: HumanEval 89.2 percent, MBPP 81.3 percent, and SWE-bench Verified 42.1 percent.
• Hardware: Full FP16 weights need about 24GB of VRAM. 8-bit quantization runs on a 16GB GPU.
• Local API: Works with vLLM, llama.cpp, and Ollama, and exposes an OpenAI-compatible endpoint.
• Market context: The release adds pressure on paid coding APIs as developers seek self-hosted alternatives.

Free AI News is an independent editorial publication. Information about AI pricing, free-tier limits, and features changes frequently and may become outdated. Always verify current details through the vendor’s official pages. Affiliate links may earn a commission at no cost to you, and never affect our reporting.