Mellum Goes Open Source: A Purpose-Built LLM for Developers, Now on Hugging Face

Anton Semenkin Michelle Frost

Read this post in other languages:

• Français

Mellum doesn’t try to know everything. It’s designed to do one thing really well: code completion. We call it a focal model – built with purposeful depth and not concerned with chasing breadth.

But code completion is just the start.

Mellum will grow into a family of focal models, each specialized for different coding tasks – from code completion to diff prediction and beyond.

Now, the base model is open-sourced and available on Hugging Face. Whether you’re building tools, running research experiments, or just curious, you’ll have full access to a fast, multilingual model*.

*Mellum supports code completion for Java, Kotlin, Python, Go, PHP, C, C++, C#, JavaScript, TypeScript, CSS, HTML, Rust, Ruby. 

🤔 Why open-source Mellum?

This question was the subject of a big internal discussion.

Mellum is not just a fine-tuned version of an open-source model. It’s a model we trained from scratch to power cloud-based code completion in JetBrains IDEs, and it was released to the public last year. It’s also the first in a planned family of code-specialized models.

So why open-source it?

Because we believe in transparency, collaboration, and the power of shared progress. From Linux and Git to Node.js and Docker, open source has driven some of the biggest leaps in technology. With open-source LLMs now outperforming some industry leaders, it’s reasonable to assume that AI’s general evolution might follow a similar trajectory.

Mellum isn’t a plug-and-play solution. By releasing it on Hugging Face, we are offering researchers, educators, and advanced teams the opportunity to explore how a purpose-built model works under the hood. 

What is a focal model?

In machine learning, specialization isn’t new – it’s a core approach that has guided model design for decades, with models built to solve specific tasks efficiently and effectively. Somewhere along the way, the AI conversation shifted towards general-purpose models that aim to do everything, often at a massive computational and environmental cost. 

Focal models return to that original principle: build models to excel in one area.

Think of it like T-shaped skills – a concept where a person has a broad understanding across many topics (the horizontal top bar or their breadth of knowledge), but deep expertise in one specific area (the vertical stem or depth). Focal models follow this same idea: they aren’t built to handle everything. Instead, they specialize and excel at a single task where depth truly delivers value. 

Mellum is a clear example. It’s a small, efficient model designed specifically for code-related tasks, starting with code completion.

Why did we take this approach? Because not every problem demands a generalist solution, and not every team has the resources or need to run large, catch-all models.

Focal models like Mellum offer clear advantages:

• Purpose-built precision for domain-specific tasks
• Cost efficiency when it comes to running and deploying them
• Lower computation and carbon footprints
• Greater accessibility for researchers, educators, and smaller teams

This isn’t a step backward – it’s applying proven principles of specialization to modern AI problems. We see that as a smarter way forward.

How does Mellum perform?

Mellum is a multilingual, 4B parameter model optimized specifically for code completion. We benchmarked it on several datasets across multiple languages, and also ran extensive human evaluations in JetBrains IDEs. In this post, we’ll provide some evaluation data for Mellum compared to some bigger models. Full details, results, and comparisons are available on the model card.

Who Mellum is (and isn’t) for

Let’s be real – the average developer probably won’t fine-tune or deploy Mellum. That’s okay.

Instead, the current version of Mellum on Hugging Face is meant for:

1. AI/ML researchers: Especially those exploring AI’s role in software development, benchmarking, or model interpretability.
2. AI/ML engineers and educators: As a foundation for learning how to build, fine-tune, and adapt domain-specific language models, or to support educational programs focused on LLM architecture and specialization.

Try Mellum today

Mellum is now live on Hugging Face. This is just the beginning. We’re not chasing generality – we’re building focus. If Mellum sparks even one meaningful experiment, contribution, or collaboration, we would consider it a win.

We’d love for you to join us by trying Mellum for yourself.

Explore Mellum on Hugging Face

Subscribe to JetBrains AI Blog updates

Subscribe form

By submitting this form, I agree to the JetBrains Privacy Policy Notification icon

By submitting this form, I agree that JetBrains s.r.o. ("JetBrains") may use my name, email address, and location data to send me newsletters, including commercial communications, and to process my personal data for this purpose. I agree that JetBrains may process said data using third-party services for this purpose in accordance with the JetBrains Privacy Policy. I understand that I can revoke this consent at any time in my profile. In addition, an unsubscribe link is included in each email.

Submit

Thanks, we've got you!