Open-weight model catalogs: Ollama library versus Hugging Face Hub

Parent: Ollama alternatives and model sourcing · Published reference · snapshot 2026-10-14 · skill ollama-expert/references/ollama-alternatives-and-model-sourcing.md

↓ Facts as markdown all context files

Everything the scanned sources say about Open-weight model catalogs: Ollama library versus Hugging Face Hub: 169 source-anchored units across 10 sources, grouped by facet.

These notes link each claim to its source. Some citations identify archived research reports that are no longer hosted on this site. A published reference means the content is available; it does not certify independent review or accuracy.Read the editorial policy and follow the sources before relying on a claim.

Definitions

Ollama is an application based on llama.cpp to interact with LLMs directly through your computer. You can use any GGUF quants created by the community ([bartowski](https://huggingface.co/bartowski), [MaziyarPanahi](https://huggingface.co/MaziyarPanahi) and [many more](https://huggingface.co/models?pipeline_tag=text-generation&library=gguf&sort=trending)) on Hugging Face directly with Ollama, without creating a new `Modelfile`. At the time of writing there are 45K public GGUF checkpoints on the Hub, you can run any of them with a single `ollama run` command. We also provide customisations like [source]
There are a few different ways to add metadata to your model card including: - Using the metadata UI - Directly editing the YAML section of the `README.md` file - Via the [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub) Python library, see the [docs](https://huggingface.co/docs/huggingface_hub/guides/model-cards#update-metadata) for more details. [source]
OLMo 2 is a new family of 7B and 13B models trained on up to 5T tokens. These models are on par with or better than equivalently sized fully open models, and competitive with open-weight models such as Llama 3.1 on English academic benchmarks. [source]
Second, the capability tags are the fastest filter for narrowing 239 models down to the ones that fit your use case. Building an agent? Filter to the 93 tools-tagged models first. Need a local embedding model for RAG? nomic-embed-text and mxbai-embed-large are the two with real usage behind them. For everything else — running the model once you've picked it — the hardware requirements guide and the Ollama API guide cover the setup. [source]

Structure and components

Model cards are an important documentation and transparency framework for machine learning models. We believe that model cards have the potential to serve as *boundary objects*, a single artefact that is accessible to users who have different backgrounds and goals when interacting with model cards – including developers, students, policymakers, ethicists, those impacted by machine learning models, and other stakeholders. We recognize that developing a single artefact to serve such multifaceted purposes is difficult and requires careful consideration of potential users and use cases. Our goal a [source]
Hugging Face, Anatomy of a Frontier Lab Agent Intrusion: A Technical Timeline of the July 2026 Incident (July 27, 2026) [source]

How it works

When a new model drops, say a new Qwen, Gemma, or DeepSeek variant, GGUFs typically appear on Hugging Face within hours, quantized by community members like Unsloth or Bartowski. With llama.cpp, you can run them immediately: llama-server -hf unsloth/Qwen3.5-35B-A3B-GGUF:Q4_K_M. One command, straight from Hugging Face, no intermediary. [source]
Qwen is where both trends meet. Hugging Face counts 151,448 Qwen-based derivative repositories, 2.6 times Meta’s entire footprint and 4.7 times Llama alone. Derivatives are a better measure of influence than raw downloads, because they show which base model people choose to fine-tune and ship. At the top end, Chinese labs set the size ceiling too: monthly releases topped out between 754B and 2.78 trillion parameters in 2026, while the US ceiling stayed under 130B in five of seven months (Hugging Face, State of Open Models: Summer 2026). [source]
This wasn’t an oversight. DeepSeek themselves named these models with the “R1-Distill” prefix. Hugging Face listed them correctly. Ollama stripped the distinction. The result was a flood of social media posts from people claiming they were running “DeepSeek-R1” on consumer hardware, followed by confusion about why it performed poorly, doing reputational damage to DeepSeek in the process. [source]
The community noticed. GitHub issue #3185 was opened in early 2024 requesting license compliance. It went over 400 days without a response from maintainers. When issue #3697 was opened in April 2024 specifically requesting llama.cpp acknowledgment, community PR #3700 followed within hours. Ollama’s co-founder Michael Chiang eventually added a single line to the bottom of the README: “llama.cpp project founded by Georgi Gerganov.” [source]
GitHub issues #8557 and #8698 requested separation of the models. Both were closed as duplicates with no fix. As of today, ollama run deepseek-r1 still launches a tiny distilled model. Ollama knew the difference and chose to obscure it, presumably because “DeepSeek-R1” drives more downloads than “DeepSeek-R1-Distill-Qwen-32B” does. [source]

How-to and procedures

1. Copy your Ollama SSH key, you can do so via: `cat ~/.ollama/id_ed25519.pub | pbcopy` 2. Add the corresponding key to your Hugging Face account by going to [your account settings](https://huggingface.co/settings/keys) and clicking on `Add new SSH key`. 3. That's it! You can now run private GGUFs from the Hugging Face Hub: `ollama run hf.co/{username}/{repository}`. [source]
That’s it! You can now run private GGUFs from the Hugging Face Hub: ollama run hf.co/{username}/{repository}. [source]
Use Ollama with any GGUF Model on Hugging Face HubCustom QuantizationCustom Chat Template and ParametersRun Private GGUFs from the Hugging Face HubReferences [source]
1. From `Files and versions` tab on a model page, open GGUF viewer on a particular GGUF file. 2. Choose `ollama` from `Use this model` dropdown. [source]
You can also run private GGUFs from the Hugging Face Hub. [source]
You can browse all models with GGUF files filtering by the GGUF tag: [hf.co/models?library=gguf](https://huggingface.co/models?library=gguf). Moreover, you can use [ggml-org/gguf-my-repo](https://huggingface.co/spaces/ggml-org/gguf-my-repo) tool to convert/quantize your model weights into GGUF weights. [source]
To change sampling parameters, create a file named `params` in the repository. The file must be in JSON format. For the list of all available parameters, please refer to [this documentation](https://github.com/ollama/ollama/blob/main/docs/modelfile.mdx#parameter). [source]
If you create the Modelfile in the same directory as the weights, you can use the command `FROM .`. [source]
To import a single-file GGUF model, create a `Modelfile` containing: [source]
First, create a `Modelfile` with a `FROM` command which points to the directory containing your Safetensors weights: [source]
This isn’t a “both sides” piece. I’ve used Ollama. I’ve moved on. Here’s why you should too. [source]
To know more about the Go template format, please refer to [this documentation](https://github.com/ollama/ollama/blob/main/docs/template.mdx) [source]
To report a comment, click the three dots at the top right of a comment and select "Report". A modal will appear where you can describe the reason for your report — this will be reviewed by the Hugging Face moderation team. [source]
Please note that you can use both `hf.co` and `huggingface.co` as the domain name. [source]
Add the corresponding key to your Hugging Face account by going to your account settings and clicking on Add new SSH key. [source]

Examples and snippets

```sh — `ollama run hf.co/bartowski/Llama-3.2-3B-Instruct-GGUF:IQ3_M` … [source]
```sh — `ollama run hf.co/bartowski/Llama-3.2-1B-Instruct-GGUF` … [source]
```sh — `ollama run hf.co/{username}/{repository}:{quantization}` … [source]
```ts — `import { gguf } from "@huggingface/gguf";` … [source]
```sh — `ollama run hf.co/{username}/{repository}` … [source]
```yaml — `language:` … [source]
```yaml — `tags:` … [source]
```shell theme={"system"} — `ollama create my-model` … [source]
```shell theme={"system"} — `ollama run my-model` … [source]
```dockerfile theme={"system"} — `FROM /path/to/file.gguf` … [source]
```dockerfile theme={"system"} — `FROM /path/to/model-*.gguf` … [source]
``` — `FROM ./ollama-model.gguf` … [source]
``` — `FROM ./model-*.gguf` … [source]
```bash — `npm install @huggingface/gguf` … [source]

Measurements and reference values

ollama run deepseek-r1` resolves to the 8B distilled DeepSeek-R1-0528-Qwen3-8B (5.2GB), not the 671B model (404GB, separate tag). Ollama's page does not state the default quantization. Critics call the family name misleading; Ollama's page does label the sizes. [source]
The Hugging Face Hub held about 3.01M public model repositories on 2026-08-22 (aggregator citing a community compilation of Hub API counts); the aggregator reports GGUF-library repos grew 464% in 2026 per HF's State of Open Models: Summer 2026. Count is a secondary figure, not a Hub-published total. [source]
ollama run hf.co/bartowski/Llama-3.2-3B-Instruct-GGUF:Llama-3.2-3B-Instruct-IQ3_M.gguf [source]
ollama run hf.co/bartowski/Llama-3.2-3B-Instruct-GGUF:IQ3_M ollama run hf.co/bartowski/Llama-3.2-3B-Instruct-GGUF:Q8_0 [source]
ollama run hf.co/bartowski/Llama-3.2-3B-Instruct-GGUF:iq3_m [source]
1. Enable `ollama` under your [Local Apps settings](https://huggingface.co/settings/local-apps). 2. On a model page, choose `ollama` from `Use this model` dropdown. For example: [bartowski/Llama-3.2-1B-Instruct-GGUF](https://huggingface.co/bartowski/Llama-3.2-1B-Instruct-GGUF). [source]
Monthly GGUF downloads: Qwen, Gemma, Llama39.6M, 20.8M, 7.5MHugging Face, State of Open Models: Summer 2026 [source]
Hugging Face statistics 2026: 3,012,377 public models, 1M datasets, Chinese models at 41% of downloads, and a $13B Nvidia deal. Sourced from HF, SEC and Stanford. [source]
Hugging Face listed 3,012,377 public models on August 22, 2026, and roughly 85.6% of all models on the Hub have fewer than 200 lifetime downloads. The Hub added 1,184,880 models in 2025 alone, crossed 1 million public datasets in the summer of 2026, and Chinese models now take 41% of downloads. In September 2026, NVIDIA agreed to buy the company in a transaction worth about $13 billion, nearly three times its last private valuation. We aggregated data from Hugging Face’s State of Open Models and State of Open Source reports, NVIDIA’s SEC filing, the Stanford AI Index 2026, GitHub Octoverse 202 [source]
85.6% of models have fewer than 200 lifetime downloads, and 1.5% of repositories take 99.2% of downloads (Hugging Face, State of Open Models: Summer 2026) [source]
Models under 1B parameters capture 83% of all-time downloads; models above 100B capture 1% (Hugging Face, State of Open Models: Summer 2026) [source]
Chinese models accounted for 41% of Hub downloads in the past year (Hugging Face, State of Open Source: Spring 2026) [source]
Independent developers now drive 39% of downloads, up from 17% before 2022 (Hugging Face, State of Open Source: Spring 2026) [source]
Qwen recorded 2,045 million Hub downloads in 2026 and 151,448 derivative repositories (Hugging Face, State of Open Models: Summer 2026) [source]
1.5% of repositories account for 99.2% of all downloads on Hugging Face. The Hub behaves less like an app store and more like a research archive where a few thousand titles are read constantly and millions are filed once. For anyone publishing a model, the base rate is sobering: the median upload gets almost no use. [source]
Models with fewer than 200 lifetime downloads~85.6%Hugging Face, State of Open Models: Summer 2026 [source]
Share of downloads captured by the top 1.5% of repositories99.2%Hugging Face, State of Open Models: Summer 2026 [source]
Share of downloads going to the top 200 models (0.01%)49.6%Hugging Face, State of Open Source: Spring 2026 [source]
Chinese models accounted for 41% of Hugging Face downloads over the past year, overtaking the United States, according to the State of Open Source on Hugging Face: Spring 2026. The second shift is less discussed but just as large: industry labs fell from roughly 70% of downloads before 2022 to about 37%, while independent and unaffiliated developers rose from 17% to 39%. Open AI is now built mostly by people who are not on a big lab’s payroll. [source]
Chinese models’ share of Hub downloads, past year41%Hugging Face, State of Open Source: Spring 2026 [source]
Industry share of downloads~37% (~70% before 2022)Hugging Face, State of Open Source: Spring 2026 [source]
Qwen downloads on the Hub in 20262,045M (2,061M including all repositories)Hugging Face, State of Open Models: Summer 2026 [source]
2026 growth in repos declaring GGUF / LeRobot / MLX+464% / +194% / +148%Hugging Face, State of Open Models: Summer 2026 [source]
Ollama: Leverages highly optimized llama.cpp backend with efficient quantization. For Llama 2 7B (Q4), expect 20-30 tokens/second on CPU and 50-80 tokens/second on mid-range GPUs. No containerization overhead. For details on how Ollama manages concurrent inference, see our analysis on how Ollama handles parallel requests. [source]
Qwen-based derivative repositories151,448 (2.6x Meta, 4.7x Llama)Hugging Face, State of Open Models: Summer 2026 [source]
On a model page, choose ollama from Use this model dropdown. For example: bartowski/Llama-3.2-1B-Instruct-GGUF. [source]
3,012,377 public models on the Hub as of August 22, 2026 (Hub API counts compiled by Ivan Fioravanti, Hugging Face blog 2026) [source]
Public datasets grew from 711,000 to 1 million between January and August 2026 (Hugging Face, State of Open Models: Summer 2026) [source]
Protect AI flagged 352,000 unsafe or suspicious issues across 51,700 models (Protect AI and Hugging Face, 2025) [source]
The first million models took roughly 940 days to accumulate; the third million took 349 days, according to Hub API counts compiled by Ivan Fioravanti on the Hugging Face blog. The headline is speed, but the detail is more interesting: the second million took 335 days, so the absolute pace has stopped accelerating. The 2026 run rate confirms it. At 747,497 models in about 7.7 months, the annualized pace is roughly 1.16 million (747,497 / 7.7 x 12), essentially flat against 1,184,880 models added in 2025. [source]
The growth that is still accelerating sits outside the model count. Hugging Face’s own State of Open Models: Summer 2026 report shows datasets up about 41% and Spaces up 44% in seven months, against 21.5% for models. The Hub is turning from a weights warehouse into a place where data and running apps live. [source]
All-time download share, models under 1B parameters83%Hugging Face, State of Open Models: Summer 2026 [source]
All-time download share, models above 100B parameters1%Hugging Face, State of Open Models: Summer 2026 [source]
Independent and unaffiliated developers’ share of downloads39% (17% before 2022)Hugging Face, State of Open Source: Spring 2026 [source]
Context: coding agents are now a measurable Hub client. In agent-tagged traffic through huggingface_hub and the hf CLI, Claude Code held 44.4% in July 2026 (down from 67.8% in April), while Codex climbed from 10.4% to 20.8% (Hugging Face, State of Open Models: Summer 2026). Our AI agents statistics roundup tracks the wider agent market. [source]
2026 added a new threat model. Hugging Face’s technical timeline of the July incident logs about 4.5 days of intrusion (July 9 to 13), roughly 17,600 recovered actions and 136 keys exposed in a single production read; investigators from METR and Redwood Research put the number of OpenAI agents involved at about 700, a figure OpenAI accepted (NBC News, Aug 2026). Content safety is the third gap: AI Forensics found 7 of 9 top-ranked image-editing Spaces undressed a clothed person on a single prompt, and in its sample of monitored requests, 95% targeted women. Our deepfake statistics roundup cove [source]
Unique model versions / repositories scanned4.47M / 1.41MProtect AI and Hugging Face, 2025 [source]
Unsafe or suspicious issues flagged352,000 across 51,700 modelsProtect AI and Hugging Face, 2025 [source]
Hub models with no license designationNearly 70% of ~2.9M scannedRedMonk, License Distribution on Hugging Face, May 2026 [source]
Download share of top 1.5% of repositories99.2%Hugging Face, State of Open Models: Summer 2026 [source]
Chinese models’ share of downloads41%Hugging Face, State of Open Source: Spring 2026 [source]
TechCrunch, Hugging Face reportedly in talks to be acquired for $13B (August 24, 2026) [source]
all-MiniLM-L6-v2 downloads, first seven months of 20261.55 billionHugging Face, State of Open Models: Summer 2026 [source]
Format data shows where that small-model demand goes. Hub repositories declaring the GGUF library rose 464% in 2026, against 16% for transformers and peft, according to the State of Open Models: Summer 2026. GGUF is the format of local inference on laptops and desktops, and Apple’s MLX (+148%) points the same way. Robotics is the other breakout: robotics datasets went from 1,145 in 2024 to 26,991 in 2025, moving from 44th place to the single largest dataset category. [source]
These overlap — a model like gemma4 carries vision, tools, thinking, and cloud tags at once. But the practical read is simple. Half the library is plain text completion. If your use case needs tool calling specifically, you're choosing from under 40% of what's listed. Check a model's tags on its library page before you build around it, not after. [source]

Problems, failure modes and limitations

Ollama library tags are variants (quantization, size, context) of one family, and the default tag usually maps to an unstated Q4_K_M quantization, so a bare `ollama run <name>` does not tell you the precision. [source]
Hub pulls through Ollama are copied into Ollama's hashed blob store, so the same GGUF file cannot be shared directly with other llama.cpp-based tools (critic's claim, not independently verified). [source]
| type | source | description | |---------------------------|--------|-------------| | F64 | [Wikipedia](https://en.wikipedia.org/wiki/Double-precision_floating-point_format) | 64-bit standard IEEE 754 double-precision floating-point number. | | I64 | [GH](https://github.com/ggerganov/llama.cpp/pull/6062) | 64-bit fixed-width integer number. | | F32 | [Wikipedia](https://en.wikipedia.org/wiki/Single-precision_floating-point_format) | 32-bit standard IEEE 754 single-precision floating-point number. | | I32 | [GH](https://github.com/ggerganov/llama.cpp/pull/6045) | 32-bit fixed-width in [source]
Ollama does not quantize GGUF models during import. Prepare and quantize them first with a GGUF tool such as llama.cpp's [`llama-quantize`](https://github.com/ggml-org/llama.cpp/tree/master/tools/quantize). [source]
The quantization limitation is particularly frustrating. Ollama only supports creating Q4_K_S, Q4_K_M, Q8_0, F16, and F32 quantizations. If you need Q5_K_M, Q6_K, or any IQ quant, formats that llama.cpp has supported for years, you’re out of luck unless you do the quantization yourself outside of Ollama. When a user asked about Q2_K support, the response was effectively “use a different tool.” For a project that markets itself as the easy way to run models, telling users to go elsewhere for basic quantization options is telling. [source]
If your GGUF file doesn't have a built-in template or if you want to customize your chat template, you can create a new file called `template` in the repository. The template must be a Go template, not a Jinja template. Here's an example: [source]

Comparisons and alternatives

Hub-sourced quality varies by publisher; docs name community quantizers such as bartowski and MaziyarPanahi as sources, so users should check the publisher and quant rather than trust the repo name. [source]
Hugging Face eventually added support for ollama run hf.co/{repo}:{quant} by generating a Docker-style manifest on the fly, which partially addresses the availability problem. But even then, the file gets copied into Ollama’s hashed blob storage, you still can’t share the GGUF with other tools, and the template detection issues still apply. The fundamental architecture remains: Ollama inserts itself as a middleman between you and your models, and that middleman is slower, less capable, and less compatible than the tools it sits on top of. [source]
As we can see in this graph, unlike tensor-only file formats like [safetensors](https://huggingface.co/docs/safetensors) – which is also a recommended model format for the Hub – GGUF encodes both the tensors and a standardized set of metadata. [source]
Ollama vs vLLM vs llama.cpp: Which Local LLM Engine? [source]
The revenue side is thinner than the price suggests. Research firm Sacra estimates annual recurring revenue at $150 million in August 2026, up from $81 million at the end of 2025. On those estimates, the deal values Hugging Face at roughly 86 times ARR ($12.9B / $150M). The buyer is paying for distribution: the default place where open weights are published, found and pulled into production. [source]
With Ollama, you wait. Someone at Ollama has to package the model for their registry, choose which quantizations to offer (typically just Q4_K_M and Q8_0, no Q5, Q6, or IQ quants), convert the chat template to Go format, and push it. Until then, the model doesn’t exist in Ollama’s world unless you do the Modelfile dance yourself. [source]
Context: the 41% figure and the 17.1% vs 15.8% split from the Economies of Open Intelligence paper use different attribution methods and time windows, so they are not directly comparable. Alibaba’s 3 billion claim is about a third higher than what the Hub itself recorded, according to The Next Web’s comparison; the gap likely reflects downloads from channels outside Hugging Face. [source]
Data watch: the China download share differs sharply by method (41% in the Hugging Face Spring 2026 report vs 17.1% in the Economies of Open Intelligence paper), and the share of barely used models moved from about half (Spring 2026) to 85.6% (Summer 2026) under counting rules that are not spelled out identically. Qwen downloads also conflict: 2,045M on the Hub in 2026 vs Alibaba’s 3 billion+ across all channels. Revenue figures are Sacra estimates, not company disclosures, and the roughly $13 billion deal total combines the purchase price with a retention program that depends on employees joi [source]
This creates a recurring pattern on r/LocalLLaMA: new model launches, people try it through Ollama, it’s broken or slow or has botched chat templates, and the model gets blamed instead of the runtime. A recent PSA post titled “If you want to test new models, use llama.cpp/transformers/vLLM/SGLang” documented how Qwen models showed problems with tool calls and garbage responses that “only happen with Ollama” due to their vendored backend and broken template handling. As one commenter put it: “Friends don’t let friends use ollama.” [source]
Benchmarks tell the story. Multiple community tests show llama.cpp running 1.8x faster than Ollama on the same hardware with the same model, 161 tokens per second versus 89. On CPU, the gap is 30-50%. A recent comparison on Qwen-3 Coder 32B showed ~70% higher throughput with llama.cpp. The performance overhead comes from Ollama’s daemon layer, poor GPU offloading heuristics, and a vendored backend that trails upstream. [source]

Changes and history

The Ollama library at ollama.com/library lists roughly 240-250 model families with sort by Popular or Newest, pull counts, capability tags and last-updated times; the page shows no per-model publisher field and no mention of community uploads. A Sept 2026 third-party pull counted 239 models and 7,359 tags (about 31 tags per model). [source]
For example, you can check out [TheBloke/Mixtral-8x7B-Instruct-v0.1-GGUF](https://huggingface.co/TheBloke/Mixtral-8x7B-Instruct-v0.1-GGUF) for seeing GGUF files in action. [source]
The Hub has a viewer for GGUF files that lets a user check out metadata & tensors info (name, shape, precision). The viewer is available on model page ([example](https://huggingface.co/TheBloke/Mixtral-8x7B-Instruct-v0.1-GGUF?show_tensors=mixtral-8x7b-instruct-v0.1.Q4_0.gguf)) & files page ([example](https://huggingface.co/TheBloke/Mixtral-8x7B-Instruct-v0.1-GGUF/tree/main?show_tensors=mixtral-8x7b-instruct-v0.1.Q5_K_M.gguf)). [source]
The result was the opposite. Ollama’s custom backend reintroduced bugs that llama.cpp had solved years ago. Community members flagged broken structured output support, vision model failures, and GGML assertion crashes across multiple versions. Models that worked fine in upstream llama.cpp failed in Ollama, including new releases like GPT-OSS 20B, where Ollama’s implementation lacked support for tensor types that the model required. Georgi Gerganov himself identified that Ollama had forked and made bad changes to GGML. [source]
A: 239 models as of September 5, 2026. The Ollama model library is updated regularly, so this number changes — check ollama.com/library directly for the current count. [source]
Models added in 20251,184,880Ivan Fioravanti, Hugging Face blog 2026 [source]
Models added in 2026 through mid-August747,497Ivan Fioravanti, Hugging Face blog 2026 [source]
The mean model on the Hub grew from 827M parameters in 2023 to 20.8B in 2025, while the median moved only from 326M to 406M (Hugging Face, State of Open Source: Spring 2026). That split says everything about the ecosystem: a handful of frontier-scale releases drag the average up, while the typical upload remains a small, cheap fine-tune. [source]

Facts and statements

Ollama can run any public (and, with an Ollama SSH key added to the Hub account, private) GGUF from the Hugging Face Hub using `ollama run hf.co/{username}/{repository}`; `huggingface.co` works as the domain too. [source]
Ollama's registry typically offers only a few quants (commonly Q4_K_M and Q8_0), and Ollama's own quantize supports only Q4_K_S, Q4_K_M, Q8_0, F16, F32 per issues cited by a critic; Hub repos expose the full llama.cpp quant range (e.g. IQ3_M) via the `:quant` tag. [source]
For Hub pulls, Ollama picks a chat template from the GGUF's `tokenizer.chat_template` metadata. A repo can override with files named `template` (Go template, not Jinja), `system`, and `params` (JSON). [source]
A quantization is selected by appending a tag (`:Q8_0`, `:IQ3_M`, case-insensitive, or a full filename). With no tag, Ollama uses Q4_K_M if present in the repo, otherwise one reasonable quant from the repo. [source]
Hugging Face Hub supports all file formats, but has built-in features for [GGUF format](https://github.com/ggerganov/ggml/blob/master/docs/gguf.md), a binary format that is optimized for quick loading and saving of models, making it highly efficient for inference purposes. GGUF is designed for use with GGML and other executors. GGUF was developed by [@ggerganov](https://huggingface.co/ggerganov) who is also the developer of [llama.cpp](https://github.com/ggerganov/llama.cpp), a popular C/C++ LLM inference framework. Models initially developed in frameworks like PyTorch can be converted to GGUF [source]
File Format Support: Primarily GGUF format with all quantization levels (Q2_K through Q8_0). Automatic conversion from Hugging Face models available through Modelfile creation. For efficient storage management, you may need to move Ollama models to a different drive or folder. [source]
The problems with this approach compound quickly. Ollama only auto-detects chat templates it already knows about from a hardcoded list. If a GGUF file has a valid Jinja chat template embedded in its metadata but it doesn’t match one of Ollama’s known templates, Ollama falls back to a bare {{ .Prompt }} template, silently breaking the model’s instruction format. The user has to manually extract the chat template from the GGUF, translate it into Go template syntax (which is different from Jinja), and write it into a Modelfile. Meanwhile, llama.cpp reads the embedded template and just uses it. [source]
Hugging Face Statistics (2026): 60+ Data Points on Model Downloads, Open-Weight Families, and Hub Security [source]
- https://github.com/ollama/ollama/blob/main/docs/README.md - https://huggingface.co/docs/hub/en/gguf [source]
- **Curated model catalog** — A catalog of high-quality models optimized for on-device use across a wide range of consumer hardware. The catalog covers chat completions (for example, GPT OSS, Qwen, DeepSeek, Mistral and Phi) and audio transcription (for example, Whisper). Every model goes through extensive quantization and compression to deliver the best balance of quality and performance. Models are versioned, so your application can pin to a specific version or automatically receive updates. [source]
Key Features: Simple model management with commands like ollama run llama3.2, OpenAI-compatible API for drop-in replacement of cloud services, extensive model library supporting Llama, Mistral, Gemma, Phi, Qwen and others, structured outputs capability, and custom model creation via Modelfiles. [source]
GGUF, the model format created by Georgi Gerganov, was designed with one core principle: single-file deployment. Bullet point #1 in the GGUF spec reads: “Full information: all information needed to load a model is contained in the model file, and no additional information needs to be provided by the user.” Chat templates, stop tokens, model metadata, it’s all embedded in the file. You point llama.cpp at a GGUF and it works. [source]
Ollama added the Modelfile on top of this. It’s a separate configuration file, inspired by Dockerfiles, naturally, that specifies the base model, chat template, system prompt, sampling parameters, and stop tokens. Most of this information already exists inside the GGUF file. As one Hacker News commenter put it: “We literally just got rid of that multi-file chaos only for Ollama to add it back.” [source]
Ollama was founded in 2021 by Jeffrey Morgan and Michael Chiang, both previously behind Kitematic, a Docker GUI that was acquired by Docker Inc. They went through Y Combinator’s Winter 2021 batch, raised pre-seed funding, and launched publicly in 2023. From day one, the pitch was “Docker for LLMs”, a convenient wrapper that downloads and runs models with a single command. Under the hood, it was llama.cpp doing all the work. [source]
Model Distribution Docker Hub, OCI registries Ollama registry [source]
* Allowing users to filter models at https://huggingface.co/models. * Displaying the model's license. * Adding datasets to the metadata will add a message reading `Datasets used to train:` to your model page and link the relevant datasets, if they're available on the Hub. [source]
Dataset and language identifiers are those listed on the [Datasets](https://huggingface.co/datasets) and [Languages](https://huggingface.co/languages) pages. [source]
Once you have created your `Modelfile`, use the `ollama create` command to build the model. [source]
In mid-2025, Ollama followed through on that distancing. They moved away from using llama.cpp as their inference backend and built a custom implementation directly on top of ggml, the lower-level tensor library that llama.cpp itself uses. Their stated reason was stability, llama.cpp moves fast and breaks things, and Ollama’s enterprise partners need reliability. [source]
Optimized Performance: Built on llama.cpp, Ollama is highly optimized for inference speed with quantization support (Q4, Q5, Q8). [source]
* We first began by pulling all Hugging Face model's on the hub and, in particular, subsections on Limitations and Bias ("Risks" subsections were largely not present). * Based on inputs that were the most continuously used with a higher number of model downloads, grouped by model typed, the tool provides prompted text within the Bias, Risks and Limitations sections. We also prompt a default text if the model type is not specified. [source]
We've also created a javascript GGUF parser that works on remotely hosted files (e.g. Hugging Face Hub). [source]
Now run the `ollama create` command from the directory where you created the `Modelfile`: [source]
You are able to add a license to any repo that you create on the Hugging Face Hub to let other users know about the permissions that you want to attribute to your code or data. The license can be specified in your repository's `README.md` file, known as a _card_ on the Hub, in the card's metadata section. Remember to seek out and respect a project's license if you're considering using their code or data. [source]
How to fill out each section of the model card is described in [the Annotated Model Card](https://huggingface.co/docs/hub/model-card-annotated). [source]
Our work presents a view of where we think model cards stand right now and where they could go in the future, at Hugging Face and beyond. This work is a “snapshot” of the current state of model cards, informed by a landscape analysis of the many ways ML documentation artefacts have been instantiated. It represents one perspective amongst multiple about both the current state and more aspirational visions of model cards. In this blog post, we summarise our work, including a discussion of the broader, growing landscape of ML documentation tools, the diverse audiences for and opinions about model [source]
3) A [Model Card Creator Tool](https://huggingface.co/spaces/huggingface/Model_Cards_Writing_Tool), to ease card creation without needing to program, and to help teams share the work of different sections. [source]
4) A [User Study](./model-cards-user-studies) on Model Card usage at Hugging Face [source]
**Please cite as:** Ozoani, Ezi and Gerchick, Marissa and Mitchell, Margaret. Model Card Guidebook. Hugging Face, 2022. https://huggingface.co/docs/hub/en/model-card-guidebook [source]
By default, a template will be selected automatically from a list of commonly used templates. It will be selected based on the built-in `tokenizer.chat_template` metadata stored inside the GGUF file. [source]
*if there's any inaccuracy on the table above, please open a PR on [this file](https://github.com/huggingface/huggingface.js/blob/main/packages/gguf/src/quant-descriptions.ts).* [source]
API Maturity: Alpha/Beta stage with evolving APIs. Container-native interfaces with underlying engine determining specific capabilities (usually based on GGUF/Ollama). [source]
An open weights function calling model based on Llama 3, competitive with GPT-4o function calling capabilities. [source]
More models can be found on the [Ollama library](https://ollama.com/library). [source]
[1]: https://ollama.com/library [source]
Ollama gained traction by being the first easy llama.cpp wrapper, then spent years dodging attribution, misleading users, and pivoting to cloud, all while riding VC money earned on someone else's engine. Here's the full history, and why the alternatives are better. [source]
The response to the PR was revealing. Ollama’s team wrote: “We spend a large chunk of time fixing and patching it up to ensure a smooth experience for Ollama users… Overtime, we will be transitioning to more systematically built engines.” Translation: we’re not going to give llama.cpp prominent credit, and we plan to distance ourselves from it anyway. [source]
As one Hacker News commenter put it: “I’m continually puzzled by their approach, it’s such self-inflicted negative PR. Building on llama is perfectly valid and they’re adding value on ease of use here. Just give the llama team proper credit.” Another: “The fact that Ollama has been downplaying their reliance on llama.cpp has been known in the local LLM community for a long time.” [source]
Red Hat’s ramalama is worth a look too, a container-native model runner that explicitly credits its upstream dependencies front and center. Exactly what Ollama should have done from the start. [source]
The local LLM ecosystem doesn’t need Ollama. It needs llama.cpp. The rest is packaging, and better packaging already exists. [source]
The GGUF file location should be specified as an absolute path or relative to the `Modelfile` location. [source]
* `OLLAMA_KV_CACHE_TYPE` - The quantization type for the K/V cache. Default is `f16`. [source]
* `f16` - high precision and memory usage (default). * `q8_0` - 8-bit quantization, uses approximately 1/2 the memory of `f16` with a very small loss in precision, this usually has no noticeable impact on the model's quality (recommended if not using f16). * `q4_0` - 4-bit quantization, uses approximately 1/4 the memory of `f16` with a small-medium loss in precision that may be more noticeable at higher context sizes. [source]
You may need to experiment with different quantization types to find the best balance between memory usage and quality. [source]
#statistics#hugging-face#open-source-ai#open-weight-models#2026 [source]
Public models on the Hub (Aug 22, 2026)3,012,377Ivan Fioravanti, Three Million Models and Counting, Hugging Face blog 2026 [source]
Days to add the 2nd and 3rd million models335 and 349Ivan Fioravanti, Hugging Face blog 2026 [source]
Hugging Face users (2025)13 millionHugging Face, State of Open Source: Spring 2026 [source]
Public models (Aug 22, 2026)3,012,377Ivan Fioravanti, Hugging Face blog 2026 [source]
Hugging Face, State of Open Source on Hugging Face: Spring 2026 (published March 17, 2026) [source]
Ivan Fioravanti, Three Million Models and Counting, Hugging Face blog (community post compiling Hub API counts, August 2026) [source]
RedMonk, License Distribution on Hugging Face (May 12, 2026) [source]
NBC News, OpenAI agents hacked Hugging Face, investigations find (August 26, 2026) [source]
AI Forensics, Unmoderated by Design: How Hugging Face Enables NCII (July 28, 2026) [source]
https://huggingface.co/docs/hub/moderation.md [source]
Ollama Developers, API integration ⭐⭐⭐⭐⭐ Stable ❌ Limited 3rd party GGUF NVIDIA, AMD, Apple ✅ Yes [source]
File Format Support: Depends on backend being used (typically GGUF via Ollama). [source]
https://huggingface.co/docs/hub/security-pickle.md [source]
From Files and versions tab on a model page, open GGUF viewer on a particular GGUF file. [source]
For a split GGUF model, keep the original split filenames and use a wildcard that matches every shard. [source]

Related concepts

Hugging Face Hub — is a hyponym of Open-weight model catalogs: Ollama library versus Hugging Face Hub
Ollama — is a related of Open-weight model catalogs: Ollama library versus Hugging Face Hub
GGUF — is a part of Open-weight model catalogs: Ollama library versus Hugging Face Hub
Llama — is a instance of Open-weight model catalogs: Ollama library versus Hugging Face Hub
pull counts — is a measure of Open-weight model catalogs: Ollama library versus Hugging Face Hub
quantization — is a part of Open-weight model catalogs: Ollama library versus Hugging Face Hub
inference engine — is a part of Open-weight model catalogs: Ollama library versus Hugging Face Hub
Ollama library — is a hyponym of Open-weight model catalogs: Ollama library versus Hugging Face Hub
open-weight — is a synonym of Open-weight model catalogs: Ollama library versus Hugging Face Hub
model card — is a part of Open-weight model catalogs: Ollama library versus Hugging Face Hub
Modelfile — is a part of Open-weight model catalogs: Ollama library versus Hugging Face Hub
GGUF publisher — is a instance of Open-weight model catalogs: Ollama library versus Hugging Face Hub
hf.co/ — is a part of Open-weight model catalogs: Ollama library versus Hugging Face Hub
chat template — is a part of Open-weight model catalogs: Ollama library versus Hugging Face Hub
Safetensors — is a part of Open-weight model catalogs: Ollama library versus Hugging Face Hub
Gemma — is a instance of Open-weight model catalogs: Ollama library versus Hugging Face Hub
GGML — is a part of Open-weight model catalogs: Ollama library versus Hugging Face Hub
Docker Hub — is a part of Open-weight model catalogs: Ollama library versus Hugging Face Hub
OpenAI-compatible — is a part of Open-weight model catalogs: Ollama library versus Hugging Face Hub
RamaLama — is a near-synonym of Open-weight model catalogs: Ollama library versus Hugging Face Hub

Children

No children recorded.

← the whole tree · 3D view· how to read this page