Exploring Single-node Language Models (SLMs) for Code
In our recent video posts on Goju Tech Talk, we dive into the emergence of single-node (or “small”) language models, colloquially known as SLMs. We believe we’re now entering the Era of SLMs. Since those posts, a number of people have reached out for guidance on which SLMs to use in place of — or as companions to — LLMs. In this article, I provide a brief list of SLMs that we think are (i) worthy of exploration, (ii) have reasonable software licensing, and (iii) are less likely to contain malicious or suspicious behaviors. We’ll focus only on coding-SLMs (i.e., SLMs that are principally used for creating software).* For later revisions, we’ll include other domains.
*This article will likely be iteratively refined as we learn more about coding SLMs.
Sandbox Before Downloading
Before using any locally downloaded SLM, you should ensure you are properly sandboxed. Given the stochastic nature of LMs, we cannot fully verify the correctness of any LM (large or small). Stochastic AIs will make mistakes and some of them may have malicious behaviors built into their training. We are still learning about them to distill out these “bad actor” LMs. We strongly recommend you use an air gapped secure sandbox for all AI use, especially those using downloaded LMs and when using AI for the creation of software. Hackers are intent on targeting these two vectors right now. We also recommend against using any Chinese models (e.g., DeepSeek or Gwen) due to growing and global privacy concerns around software and hardware in Chinese-based systems. This is not a political statement, it is a recommendation based on established and published data.
Model Licensing
We need to discuss software licensing before getting into the models. This is because the license you are under is almost always more important than the model itself. You must understand at least the basics about the licensing restrictions with models. Even more important than the model itself is its license and often times this is a footnote or skipped entirely by model listings. We’re not going to do that here.
Model licenses are a first-order concern. If you end up using a model with the wrong licensing permissiveness you may be legally prohibited from fine-tuning it, commercializing software you create from it, or even legally owning anything it creates. Don’t skip this section unless you’re already an expert in software licenses.
For those who plan to build commercial products with SLMs, we recommend you only use models under MIT and Apache 2.0 licenses. Do not use any model from the GNU General Public License family. The following license list is in roughly a decreasing order of how friendly they are to you. Higher — more friendly. Lower — less friendly.
Licenses
MIT. The simplest open license that exists. You can download, modify, redistribute, run commercially, sell derivatives, embed in proprietary products — anything — as long as you keep the original copyright notice somewhere in your distribution. There are no use restrictions, no patent clauses, no carve-outs. If a coding model ships under MIT, you can put it inside your closed-source IDE, fine-tune it on your private codebase, and ship the result to paying customers without asking anyone. You want a model with an MIT license.
DeepSeek-Coder (not recommended), Microsoft Phi: MIT.
Apache 2.0. Same practical freedoms as MIT, plus an explicit patent grant (the people who wrote it can’t sue you for patent infringement on what they released) and a requirement to note in your derivative work that you modified it. From a “can I use this in my company?” standpoint, it’s essentially identical to MIT.
Qwen (not recommended), IBM Granite, Intel Neural Chat: Apache 2.0.
BigCode OpenRAIL-M. “Open” + a list of prohibited use cases (e.g., no surveillance, no harassment tools, no medical decisions without human oversight, etc.). For most commercial coding work this is probably fine. For enterprise software, it’s a yellow flag because the prohibited-use list is enforceable and you have to pass it through to your downstream users.
StarCoder2 ships under this.
Meta Llama Community License. This is free for any organization so long as you have less than 700M monthly active users. Meta’s license has a fairly acceptable-use policy. It’s essentially free for ~99.99% of users, including most companies, but it’s not technically open — like MIT and Apache 2.0 — under the strict OSI definition.
CodeLlama and Llama 3.x/4 ship under this.
Here’s the most important part of model licensing: model fine-tuning implications.
When you fine-tune a model, your derivative work inherits the base model’s license. If you fine-tuning a model with an MIT license, the resulting weights are yours to license however you want (full ownership). On the other hand, if you fine-tune a model under the Llama Community License, your derivative inherits the same restrictions. This is probably fine for most uses, but worth knowing before you plan to build enterprise-scale software like I do. That’s it — now let’s get to the models!
SLMs-for-Code
Given GTT’s interest is principally rooted in coding AIs, we’ll first start with a short list of SLMs in this category. The first iteration of this article is intentionally short, so I can make it immediately available for those are already waiting for it. Over the coming weeks and months, I’ll iteratively refine and extend this to (i) be more complete, (ii) include a list of malware models, and (iii) incorporate models that cover other domains (e.g., writing, music, art, etc.). For now, here’s the list.
The recommendations below are filtered to MIT and Apache 2.0 only. The “almost free” exceptions get their own section below.
Frontier — workstation / single-GPU with quantization
IBM Granite Code — 3B / 8B / 20B / 34B, Apache 2.0. Backed by IBM for production fine-tuning support. Conservative training-data provenance (curated to exclude license-incompatible sources), which matters if you care about license-safe code generation in your output.
🔗 https://huggingface.co/ibm-granite
While the Qwen and DeepSeek family fall into this category, we won’t include them because of the rules we listed above. However, if you’re interested in using them, you may want to research Qwen3-Coder-Next and the DeepSeek-Coder family. We’ll leave that up to you (not recommended).
Laptop-friendly — 16-32GB RAM with quantization
Microsoft Phi-4 Mini Code — under 4B parameters, MIT. Phi demonstrates how far aggressive data curation can take a small model. Fast on CPU-only inference; viable on a Raspberry Pi 5 with quantization.
🔗 https://huggingface.co/microsoft
Qwen shows up here, too, with Qwen3.5-Coder, but — same rules as before. Not recommended, but you’re welcome to research on your own if you’re interested.
Intel-flavored
Intel Neural Chat 7B — Mistral-7B fine-tune by Intel, Apache 2.0. Not coding-specialized, but specifically optimized for Intel hardware (CPU + iGPU). Worth knowing about if you’re targeting Intel platforms or pairing with Intel Extension for PyTorch / OpenVINO. Especially good if you don’t have a super-charged GPU.
🔗 https://huggingface.co/Intel/neural-chat-7b-v3-1
The “Almost Permissive Enough” SLMs-for-Code
Two model families don’t quite clear the MIT / Apache 2.0 bar but are common enough in the conversation that skipping them would be dishonest:
StarCoder2 (BigCode / HuggingFace) — 3B / 7B / 15B, BigCode OpenRAIL-M license. Trained on The Stack v2 with thorough provenance vetting, which makes it one of the best choices if you care about not training a model on code with incompatible licenses. The OpenRAIL clause prohibits a specific list of misuses — for most commercial coding work this never comes up, but enterprise legal review takes longer.
🔗 https://huggingface.co/bigcode
CodeLlama (Meta) — 7B / 13B / 34B, Llama Community License. Battle-tested. Free for anyone with under 700M MAU (effectively: free for most use cases). The license has an acceptable-use policy that prohibits specific categories of use. For most users this is probably a non-issue. It’s worth knowing about as a stable, well-supported alternative to the MIT/Apache picks above.
🔗 https://huggingface.co/codellama
Net: both are usable; both come with one extra question to answer before you commit. GTT recommendation: prefer the ones that use MIT and Apache licenses, unless you’re just “playing around.”
GTT Conclusion of Version 1.0 of SLMs-for-Code
There you have it! I know it’s not a super big list, but there are a number of real options today. We anticipate that in the coming 6-12 months,
Keep Goin’ — Keep Growin’!
Goju
P.S. If you actually read this far, you may want to check out our YT, IG, and Discord in this article.