Ollama: Qwen 3.5 Architecture Lands with Safety Upgrades

Transcript

Hey there, amazing developers! Welcome back to another episode of the Ollama podcast. I'm your host, and wow, do we have some exciting updates to dive into today. Grab your favorite beverage because we're talking about some really meaningful progress that happened yesterday.

So the big story today is all about expanding horizons and building stronger foundations. The team has been working on some incredible improvements that I think you're going to love.

Let's start with the headline act - Jeffrey Morgan just landed full support for the Qwen 3.5 architecture! And when I say full support, I mean this was no small undertaking. We're talking about changes across 31 files with nearly two thousand lines of code touched. This is the kind of comprehensive work that opens up entirely new possibilities for what you can do with Ollama.

What's really cool about this update is how thoughtfully it was implemented. Jeffrey completely reworked the conversion pipeline, added robust testing - I'm talking over 500 lines of new tests - and even cleaned house by removing some old checkpoint files that were no longer needed. It's like renovating your entire kitchen while making sure you can still cook dinner every night.

But wait, there's more! Hot on the heels of that architecture support, Jeffrey followed up with specific support for the Qwen 3.5 27B model. Twenty-seven billion parameters, folks! This gives you access to some seriously powerful language modeling capabilities. The backend got the updates it needed, and the deltanet implementation was refined to handle this larger model size beautifully.

Now, while Jeffrey was working on these exciting new features, Bruce MacDonald was doing the unsung hero work that makes everything more reliable. Bruce added tensor size validation during model quantization, and let me tell you why this matters. When you're working with these massive models, you want to be absolutely certain that when you compress them down - that's what quantization does - the math still works out perfectly. Bruce's changes add those crucial safety checks that catch problems early, before they can cause headaches down the road.

What I love about Bruce's contribution is the attention to testing. He didn't just add the validation logic - he wrote comprehensive tests to make sure it works exactly as intended. That's the kind of engineering discipline that builds trust in a system.

Looking at all this work together, there's a beautiful story here about growth and reliability going hand in hand. The team isn't just adding flashy new features - they're making sure the foundation can support them properly. That's how you build software that people can depend on.

For today's focus, if you're running Ollama in your projects, this is a perfect time to explore what the Qwen 3.5 models can do for you. The 27B variant is particularly interesting if you've been hitting the limits of smaller models. And for those of you contributing to the project, notice how both of these contributors approached their work - comprehensive testing, thoughtful implementation, and clean code organization. That's the standard that makes open source projects thrive.

The validation improvements might not be as flashy as new model support, but they're the kind of reliability improvements that make your daily development experience smoother. Less time debugging weird quantization issues means more time building amazing things.

That's a wrap on today's episode! The Ollama project continues to evolve in really exciting ways, balancing innovation with reliability. Keep coding, keep contributing, and remember - every line of code you write is making this ecosystem better for everyone. Until next time, happy developing!