What Is Hugging Face? by kirupa (https://www.kirupa.com/me/index.htm) | filed under AI Fundamentals (https://www.kirupa.com/ai_fundamentals/index.htm) If you've been reading these articles in order, Hugging Face has already come up a bunch of times. In Why Training Takes a Data Center (https://www.kirupa.com/ai_fundamentals/data_centers_and_training.htm), the 4-bit Llama 3.1 8B we sized up was a community quantization shared on Hugging Face. In What Does Open Mean in Open AI Models? (https://www.kirupa.com/ai_fundamentals/what_open_means_in_ai_models.htm), the DeepSeek-R1 and gpt-oss-120b links pointed there. And in Running AI Models Locally (https://www.kirupa.com/ai_fundamentals/running_models_locally.htm), it was all over the place. It sat at the bottom of our tools figure holding the GGUF, MLX, and safetensors files, our memory math leaned on a 4.92 GB file from it, and we went there to check the licenses for Qwen 3.5, Gemma 4, and Llama 3.1. That article called Hugging Face the place where most open models live and then kept right on going without ever saying what it is. It's time to fix that! Wren, the Crumb & Co. bakery's web developer, is in the same spot. While getting Biscuit, the bakery's help desk bot, running on a laptop, Wren kept landing on Hugging Face pages without ever stopping to look around. Now the bakery's owner has two questions. What is this Hugging Face thing, and should the bakery trust a model it downloads from a website named after an emoji? In this article, we'll answer both. We'll see what Hugging Face is, where it came from, how it pays its bills, and why nearly everyone uses it. Then we'll open a real model repo, pin a version, knock on a gated model's door, climb a family tree, download a few files, and figure out what to check before trusting any of it. Onwards! What Is Hugging Face? Hugging Face is a company, but when people say Hugging Face, they usually mean its website, the Hugging Face Hub (https://huggingface.co/docs/hub/index) at huggingface.co. The Hub is a giant shared library for AI. Anyone can make an account and upload to it, and anyone can download what's public. Here is what it holds, along with the open-source code Hugging Face builds to go with it: [Image: The Hugging Face Hub at huggingface.co has three shelves. Models: trained weights and their files, over 3 million. Datasets: examples to train and test with, over 1 million. Spaces: demo apps that run in the browser, over 2 million. Below the Hub are Hugging Face's open-source libraries: transformers, datasets, diffusers, PEFT, TRL, Gradio, and huggingface_hub.] (https://www.kirupa.com/ai_fundamentals/images/what_is_hugging_face_hub.png) Look at the three shelves. Models are trained weights plus the files that go with them, like the Qwen 3.5 model behind Wren's prototype. Datasets are collections of examples for training or testing models. Spaces are small web apps, usually demos, that let us try a model right in the browser. At the time of writing, the Hub's own docs (https://huggingface.co/docs/hub/index) count over 3 million models, 1 million datasets, and 2 million Spaces. The libraries along the bottom are a big part of the story too. transformers (https://github.com/huggingface/transformers) is a Python library that can load and run most of the models on the Hub. datasets (https://github.com/huggingface/datasets) loads data, diffusers (https://github.com/huggingface/diffusers) handles image, video, and audio models, PEFT (https://github.com/huggingface/peft) and TRL (https://github.com/huggingface/trl) help fine-tune and train models, Gradio (https://github.com/gradio-app/gradio) builds those demo apps, and huggingface_hub (https://huggingface.co/docs/huggingface_hub/guides/cli) comes with a command-line tool called hf. We'll use two of these in a bit. And the name? The company is named after the hugging face emoji, and that really is the character's name in the Unicode standard (https://www.unicode.org/charts/PDF/U1F900.pdf): HUGGING FACE. (Unicode's emoji list (https://unicode.org/Public/emoji/latest/emoji-test.txt) now calls it smiling face with open hands, which is a lot less fun.) From a Chatbot App to a Model Hub Hugging Face didn't start out hosting models. Here is how it got from there to here: [Image: A timeline. 2017: a chatbot app for bored teenagers. 2018: pytorch-pretrained-bert, BERT for PyTorch. 2019: renamed transformers, and anyone can upload a model. 2020: one model, one Git repo, which is the Hub. 2021: Gradio joins. 2022: BLOOM, a 176B open model, via BigScience. 2024: XetHub joins to store giant files. 2025: Pollen Robotics joins, bringing open-source robots. 2026: GGML and llama.cpp join.] (https://www.kirupa.com/ai_fundamentals/images/what_is_hugging_face_timeline.png) Start at the top. In 2017, TechCrunch (https://techcrunch.com/2017/03/09/hugging-face-wants-to-become-your-artificial-bff/) introduced Hugging Face as "a new chatbot app for bored teenagers", a digital friend you could text with and trade selfies with. That app isn't what Hugging Face is known for anymore, but the friendly emoji stuck around. The big turn came in November 2018, when the team released pytorch-pretrained-bert (https://github.com/huggingface/transformers/releases/tag/v0.1.2), a PyTorch version of Google's BERT model that came with Google's trained weights. As it added more models, it was renamed pytorch-transformers in July 2019, and when it added TensorFlow support that September, it became plain transformers (https://github.com/huggingface/transformers/releases/tag/v2.0.0). In December 2019 (https://github.com/huggingface/transformers/releases/tag/v2.3.0), anyone could make an account on huggingface.co and upload a model for other people to download, and in November 2020 (https://github.com/huggingface/transformers/releases/tag/v3.5.0), every model got its own Git repository. That's the Hub as we know it. Since then, the company has kept adding pieces. It acquired Gradio (https://huggingface.co/blog/gradio-joins-hf) in December 2021. In July 2022, BigScience, a collaboration of more than 1,000 researchers that started around Hugging Face (https://arxiv.org/abs/2211.05100) and the French NLP community, released BLOOM (https://huggingface.co/blog/bloom), a 176-billion-parameter model that writes 46 human languages and 13 programming languages. Hugging Face bought XetHub (https://huggingface.co/blog/xethub-joins-hf) in 2024 to rebuild how the Hub stores giant files and Pollen Robotics (https://huggingface.co/blog/hugging-face-pollen-robotics-acquisition) in 2025 to sell open-source robots. In February 2026, the team behind GGML and llama.cpp (https://huggingface.co/blog/ggml-joins-hf), the engine that Ollama and LM Studio build on, joined too. How Hugging Face Makes Money If uploading and downloading are free, who pays for all those terabytes? Hugging Face gives away the parts that bring people in and charges for the parts that need serious computers or company features: [Image: Two columns. Free: hosting public repos, downloading them, Spaces on a basic CPU, a quota of ZeroGPU time, and the open-source libraries. Paid: PRO at $9 a month, Team at $20 per user a month, Enterprise at $50 per user a month, GPUs for Spaces from $0.40 an hour, and Inference Endpoints from $0.033 an hour.] (https://www.kirupa.com/ai_fundamentals/images/what_is_hugging_face_money.png) Look at the free column. Those are the things that bring people to the Hub in the first place. At the time of writing, Hugging Face's storage docs (https://huggingface.co/docs/hub/storage-limits) offer free space for public repos, and its pricing page (https://huggingface.co/pricing) lists a basic CPU for Spaces as free, along with ZeroGPU, its name for a quota of time on shared GPUs. The paid column is for people who need more. PRO adds storage, GPU time, and $2 of monthly credits, Team and Enterprise add company features like single sign-on, and the rest is computing by the hour, like GPUs for Spaces and Inference Endpoints, which run a model on its own dedicated machine. There's also Inference Providers (https://huggingface.co/docs/inference-providers/index), which passes our requests to partner companies that run open models. Hugging Face says it charges their prices with no markup, so it's mostly a convenience: one account and one token for lots of models. Why Everyone Uses It There are other places to share models, so why does everyone end up here? Part of it is that Hugging Face borrowed an idea developers already trusted. If GitHub is where code lives, Hugging Face is where models live. Every model is a Git repository with a full history, public models are hosted for free, and publishing, finding, versioning, and downloading work the same way for every model. The other part is a loop that keeps feeding itself: [Image: A loop with four steps around the Hub. Labs publish new models. Developers download them and build. The community adds fine-tunes, quantizations, and demos. More people come looking, which brings the loop back to labs publishing new models there.] (https://www.kirupa.com/ai_fundamentals/images/what_is_hugging_face_loop.png) Start with the labs at the top. When OpenAI released gpt-oss in August 2025, its announcement (https://openai.com/index/introducing-gpt-oss/) put an Explore on Hugging Face button right at the top, and Hugging Face's welcome post (https://huggingface.co/blog/welcome-openai-gpt-oss) went up the same day. The community then builds on whatever arrives. Meta released Llama 3.1 (https://ai.meta.com/blog/meta-llama-3-1/) on July 23, 2024, and bartowski's repo of GGUF quantizations (https://huggingface.co/bartowski/Meta-Llama-3.1-8B-Instruct-GGUF), home of the 4.92 GB file from our memory math, was created that same day. Every new arrival brings more people, and more people make the Hub the obvious place for the next lab to publish. The libraries help too, because they make every model look the same to our code. In transformers, loading anything starts with from_pretrained and the model's name. Here is one loop that loads the tokenizers (the part that chops text into tokens, from Tokens and How They Set Your Bill (https://www.kirupa.com/ai_fundamentals/tokens_and_your_bill.htm)) for two different models: from transformers import AutoTokenizer for model_id in ["Qwen/Qwen3.5-4B", "google/gemma-4-E4B-it"]: tokenizer = AutoTokenizer.from_pretrained(model_id) print(model_id, tokenizer.tokenize("Do you have rye bread today?")) When this runs, transformers downloads each tokenizer's files from the Hub, and then it prints this: Qwen/Qwen3.5-4B ['Do', 'Ġyou', 'Ġhave', 'Ġr', 'ye', 'Ġbread', 'Ġtoday', '?'] google/gemma-4-E4B-it ['Do', '▁you', '▁have', '▁rye', '▁bread', '▁today', '?'] The Ġ and ▁ marks are each tokenizer's way of saying that a token starts with a space. Notice that the two models don't even agree on rye! Qwen splits it into r and ye, while Gemma keeps it whole, and our code didn't need to know anything about either model except its name. Those same names work outside of Python, too. Ollama (https://huggingface.co/docs/hub/ollama), LM Studio (https://lmstudio.ai/docs/app/basics/download-model), llama.cpp (https://github.com/ggml-org/llama.cpp), vLLM (https://docs.vllm.ai/en/latest/getting_started/quickstart.html), and mlx-lm (https://github.com/ml-explore/mlx-lm), the local tools from Running AI Models Locally, can all fetch models straight from the Hub at the time of writing: [Image: The Hugging Face Hub feeds five local tools. Ollama runs a GGUF with ollama run hf.co/{user}/{repo}. LM Studio searches the Hub from its Discover tab. llama.cpp downloads a model with llama cli -hf {user}/{repo}. vLLM serves a model with vllm serve {user}/{repo}. mlx-lm runs models from the mlx-community organization with --model mlx-community/{repo}.] (https://www.kirupa.com/ai_fundamentals/images/what_is_hugging_face_tools.png) So Wren can find a model once, on the Hub, and then run it with whichever tool fits the job. Some community accounts exist just to feed these tools, too. At the time of writing, the MLX Community has converted 5,852 models for Apple silicon. And when we only want to try a model before downloading anything, Spaces put demos right in the browser, often running on those free shared GPUs. Inside a Model Repo Let's open one up. Every repo on the Hub has a two-part name: who published it, then what it's called. Qwen/Qwen3.5-4B is the model called Qwen3.5-4B from the Qwen team's own account. Here is everything inside it, as listed by the hf command we'll install shortly: [Image: The 14 files in the Qwen/Qwen3.5-4B repo, 9.3 GB in all, in five groups. The model card and license: README.md at 77.7 KB and LICENSE at 11.5 KB. Settings: config.json at 3.2 KB and two preprocessor configs under 400 bytes each. The tokenizer: tokenizer.json at 12.8 MB, vocab.json at 6.7 MB, merges.txt at 3.4 MB, tokenizer_config.json at 16.7 KB, and chat_template.jinja at 7.8 KB. The weights: two safetensors shards of 5.3 GB and 4.0 GB, plus a 76.2 KB index. Git housekeeping: .gitattributes at 1.6 KB.] (https://www.kirupa.com/ai_fundamentals/images/what_is_hugging_face_repo.png) Nearly all of the 9.3 GB is the two .safetensors files, which hold the weights. A big model gets split into pieces called shards, and the small index file tells the loader which weights live in which shard. The other files are tiny. config.json describes the model's shape (here, 32 layers and a vocabulary of 248,320 tokens). The tokenizer files decide how text turns into tokens, and chat_template.jinja turns a list of chat messages into the exact text the model reads. LICENSE is the license, and README.md is the model card (https://huggingface.co/docs/hub/model-cards), with a few settings at the top, like license: apache-2.0, that the Hub uses to label and filter models. Because the repo is a Git repository, every change to it is a commit, and the Hub keeps the whole history. Here is Qwen3.5-4B's: [Image: The commit history of Qwen/Qwen3.5-4B, newest first. 851bf6e, Update README.md, March 2, 2026, which is where main points. bbaaae1, Upload 6 files, March 1, 2026, highlighted, with a handwritten note: new chat template! f80f99c, Update README.md, March 1, 2026. 1eef1f4, Upload folder using huggingface_hub, February 27, 2026. f0a06e4, initial commit, February 27, 2026.] (https://www.kirupa.com/ai_fundamentals/images/what_is_hugging_face_commits.png) The newest commit is at the top, and the main branch points at it, so code that asks for Qwen/Qwen3.5-4B gets whatever main is today. Now look at the second commit. On March 1, two days after the model went up, Upload 6 files added the LICENSE file and changed the chat template and tokenizer settings, so someone who downloaded on day one and again on day three got different files under the same name. Changes like that are usually fixes. Still, once Wren has a version that tests well, Wren can pin it by asking for a commit like 851bf6e instead of main, and it will never change out from under the bakery. Gated Models and Access Tokens Some publishers want to know who's downloading. On a gated model (https://huggingface.co/docs/hub/models-gated), we have to ask before we can see a single file. Meta's Llama 3.1 is gated, and its form asks for our name, date of birth, country, affiliation, and job title, plus a yes to the Llama 3.1 Community License. Here is the path from asking to downloading: [Image: Four steps to download a gated model. 1: Fill out the form. 2: Meta reviews it by hand, which is the highlighted step. 3: Create an access token. 4: Download with the token.] (https://www.kirupa.com/ai_fundamentals/images/what_is_hugging_face_gate.png) Step 2 can take a while, because Meta approves each request by hand. Until it does, a download fails like this: $ hf download meta-llama/Llama-3.1-8B-Instruct config.json Error: Access denied. Model 'meta-llama/Llama-3.1-8B-Instruct' requires approval. Hint: set HF_DEBUG=1 as environment variable for full traceback. Once we're approved, our code proves who we are with an access token (https://huggingface.co/docs/hub/security-tokens), a secret string we create in our account settings. We can pass it along with each request or save it once with hf auth login. Also, a gate only guards its own repo. bartowski's GGUF of the same model has no gate at all, but Meta's license still applies to it, even though nobody asks us to accept it. The Model Tree That GGUF and Meta's original are related, and the Hub keeps track. When someone uploads a model built from another one, they name the original in their model card's settings (a field called base_model), and the Hub draws a family tree on the model's page. Here is Llama 3.1 8B Instruct's tree at the time of writing: [Image: The model tree for meta-llama/Llama-3.1-8B-Instruct. Its base model is meta-llama/Llama-3.1-8B. Below it are 3,064 adapters, 3,319 fine-tunes, 106 merges, and 968 quantizations. One of the quantizations is bartowski/Meta-Llama-3.1-8B-Instruct-GGUF, whose Q4_K_M file is 4.92 GB.] (https://www.kirupa.com/ai_fundamentals/images/what_is_hugging_face_tree.png) Read it from the top. The base model, Llama 3.1 8B, came out of pretraining on huge piles of text (the stage we met in What Exactly Is an LLM? (https://www.kirupa.com/ai_fundamentals/what_is_an_llm.htm)), and Meta tuned it to follow instructions to make the Instruct model. Then the community took over. Fine-tunes are copies trained further on new examples. Adapters are small add-on files, often made with LoRA, that change a model's behavior without retraining most of its weights (Prompting vs. Fine-Tuning (https://www.kirupa.com/ai_fundamentals/prompting_vs_fine_tuning.htm) covers both). Merges blend models together, and quantizations, like bartowski's 4.92 GB file, store the same weights in fewer bits, as we saw in Quantization (https://www.kirupa.com/ai_fundamentals/quantization.htm). More than 7,400 models list this one as their starting point. Downloading a Model It's time to download something ourselves. The hf command comes with the huggingface_hub Python package: pip install -U huggingface_hub Our repo figure's file list came from a dry run (hf download Qwen/Qwen3.5-4B --dry-run), which lists what a download would fetch without fetching it. For a real download, let's grab just the small config.json, since the whole model is 9.3 GB. Here is what that printed on the Mac this article was tested on, minus a warning nudging us to log in with an access token: $ hf download Qwen/Qwen3.5-4B config.json ✓ Downloaded path: /Users/kirupa/.cache/huggingface/hub/models--Qwen--Qwen3.5-4B/snapshots/851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a/config.json Look at where the file landed. Downloads go into a shared cache in our home folder. Inside it is a folder named after the repo, and inside that, a snapshots folder holds a folder named after the exact commit we got. Now let's ask for the chat template from before Qwen's March 1 update, using the short name of the older commit: $ hf download Qwen/Qwen3.5-4B chat_template.jinja --revision 1eef1f4 ✓ Downloaded path: /Users/kirupa/.cache/huggingface/hub/models--Qwen--Qwen3.5-4B/snapshots/1eef1f4e0bc57dec8f814d1e4c714c8e0065d261/chat_template.jinja That file landed in a second snapshot folder, named after the older commit. Here is what the cache looks like now: [Image: The cache folder at ~/.cache/huggingface/hub after the two downloads. Inside models--Qwen--Qwen3.5-4B, refs records that main pointed at commit 851bf6e and that the short name 1eef1f4 means commit 1eef1f4. snapshots has one folder per commit: 851bf6e with config.json, and 1eef1f4 with chat_template.jinja. Each of those files points to a blob, which holds the actual bytes under a name made from its hash: 557d961b for config.json and 088dfe85 for the chat template.] (https://www.kirupa.com/ai_fundamentals/images/what_is_hugging_face_cache.png) Each folder in snapshots shows the repo as it was at one commit, and refs/main remembers where main pointed when we last asked. The bytes themselves live once in blobs, so a file that's the same in two commits is never stored twice. This cache is shared (https://huggingface.co/docs/huggingface_hub/guides/manage-cache) by every library built on huggingface_hub, including transformers, and from_pretrained takes a revision argument too, so our Python code can pin a commit the same way. For Wren's laptop, the most useful downloads are the GGUF files the local tools run, and Wren can grab one with hf or let the tool fetch it. Ollama's name for the 4.92 GB file from our memory math is hf.co/bartowski/Meta-Llama-3.1-8B-Instruct-GGUF:Q4_K_M, and when Ollama asks the Hub for that name, it gets that exact file. Datasets download the same way, and the datasets library loads one by name, which is handy for fine-tuning examples or a benchmark to test a model against. Can We Trust What We Download? Now for the owner's second question. Anyone can create an account and upload a model. That openness is what makes the Hub so useful, and it's also why we need to be a little careful. A model file is something our computer opens, and not every file format is just numbers: [Image: Two model files side by side. An older PyTorch file, pytorch_model.bin, uses Python's pickle format: it's a list of instructions for rebuilding objects, and mixed in with the numbers can be instructions like import os.system and call it. A handwritten note points at them: runs on load! A model.safetensors file is a header with each tensor's name, shape, and type, followed by the raw numbers, so loading it only reads data.] (https://www.kirupa.com/ai_fundamentals/images/what_is_hugging_face_pickle.png) Look at the file on the left. Older PyTorch files (usually ending in .bin, .pt, or .pth) use Python's pickle format, which is really a list of instructions for rebuilding Python objects. One instruction can import and run any function, and it runs the moment the file is loaded (https://huggingface.co/docs/hub/security-pickle). The file on the right is the fix. A safetensors (https://huggingface.co/docs/safetensors/index) file is a small header that describes the weights, followed by the raw numbers, so loading it only reads data. Hugging Face created the format, had Trail of Bits audit it (https://huggingface.co/blog/safetensors-security-audit) in 2023, and in April 2026 handed it to the PyTorch Foundation (https://huggingface.co/blog/safetensors-joins-pytorch-foundation) so that no single company owns it. This risk isn't just theory. In February 2024, JFrog's security researchers (https://jfrog.com/blog/data-scientists-targeted-by-malicious-hugging-face-ml-models-with-silent-backdoor/) reported finding about 100 models on Hugging Face with real malicious payloads. One of them, a PyTorch file in a repo called baller423/goober2 (since deleted), opened a reverse shell when it was loaded. That's a hidden connection that lets someone far away control the computer. Hugging Face does scan uploads. Every file under 2 GB goes through the ClamAV antivirus (https://huggingface.co/docs/hub/security-malware) on each commit, pickle files get an import scan that flags suspicious imports, and partner scanners from JFrog (https://huggingface.co/docs/hub/security-jfrog) and Protect AI (https://huggingface.co/docs/hub/security-protectai) add their own results next to each file. Hugging Face says its pickle scan isn't foolproof, though, so the rest is up to us. Here is what Wren checks before downloading anything: - Who published it. Qwen/ is the Qwen team's own account, and a similar-looking name could belong to anybody. - The card and license. A good card says what the model is for and how it was tested, and the license decides whether the bakery can use it at all. - The file format. Wren picks safetensors over pickle files and glances at the scan results next to each file. - Whether it runs code. A model that needs trust_remote_code=True in transformers runs Python files from its repo on our computer, so Wren reads that code first and pins the revision, just as the transformers docs (https://github.com/huggingface/transformers/blob/main/docs/source/en/models.md#custom-models) suggest. - Its family tree. A model that names its base model can be traced back to the original and its license. Conclusion So, what is Hugging Face? It's a company that started with a chatbot app for teenagers and now runs the Hub, where most open models live, plus the libraries that load them. It's popular because free hosting, Git under the hood, one from_pretrained call for every model, day-one releases from labs, and a busy community all feed each other. For open models, it's where we read the card and license, pin the version we tested, ask for gated access, follow the family tree down to the GGUF on our laptop, and check what we're about to open. That also answers the owner's questions. Biscuit's prototype runs on Qwen 3.5, a model the Qwen team published themselves under a license the bakery can live with, and Wren can pin the exact version that passed testing. The website named after an emoji turned out to be a pretty trustworthy place to shop, as long as we keep checking what we download. Browse the Hub for a while, though, and you'll run into model names like gemma-4-26B-A4B-it and Qwen3-235B-A22B. What do those A numbers mean, and why would one model have two sizes? That's where we're going next in Types of AI Models (https://www.kirupa.com/ai_fundamentals/types_of_ai_models.htm). [Mastery Quiz] Test your knowledge! Take the Hugging Face and Open Model Files Quiz: https://www.kirupa.com/quizzes/what_is_hugging_face.htm Practice with 6 multiple-choice questions and an explanation after every answer. [/Mastery Quiz]