What Is Hugging Face? AI's GitHub Explained

Hugging Face is the public warehouse and workshop for open machine learning: a website (the Hub) where people publish trained models, datasets, and demo apps, plus a family of Python libraries that load and run them. If GitHub is where source code lives, Hugging Face is where trained model weights live. Its own documentation says the Hub hosts more than two million models, and on September 3, 2026 Nvidia announced a $12.93 billion deal to buy the company. This article explains what each piece does and what it costs.

From a teenage chatbot to the center of open AI

Hugging Face was founded in 2016 in New York City by three French entrepreneurs: Clément Delangue, Julien Chaumond, and Thomas Wolf. The first product was a chatbot app aimed at teenagers, and the company took its name from the hugging-face emoji. According to Wikipedia's company entry, the founders open-sourced the model underlying that app and then pivoted toward becoming a machine learning platform.

The pivot paid off because of a software library. In October 2019, Wolf, Chaumond, Delangue, and 19 co-authors posted a paper on arXiv titled "HuggingFace's Transformers: State-of-the-art Natural Language Processing". Its abstract describes an open-source library that offers Transformer architectures through a single, unified API, backed by a curated collection of pretrained models contributed by the community. Before that, using a published research model usually meant cloning a lab's code, matching its exact library versions, and writing custom loading logic for each architecture.

Three milestones show how the company's role widened after that:

• April 28, 2021: Hugging Face launched the BigScience Research Workshop with other research groups to build an openly released large language model. In 2022 the workshop announced BLOOM, a multilingual model with 176 billion parameters.
• February 2023: A partnership with Amazon Web Services made Hugging Face products available to AWS customers.
• August 24, 2023: A $235 million Series D round valued the company at $4.5 billion, according to TechCrunch's report. Participants included Google, Amazon, Nvidia, Intel, AMD, Qualcomm, IBM, and Salesforce. At that point the company had raised $395.2 million in total, had about 10,000 customers, and employed 170 people.

In April 2025 the company acquired Pollen Robotics, a French humanoid-robotics startup, a step that took Hugging Face from software into physical machines. Then, in September 2026, came the biggest change in its history.

The biggest fact in the story: On September 3, 2026, Nvidia CEO Jensen Huang announced that Nvidia had agreed to acquire Hugging Face for $12.93 billion. Huang wrote that the platform will remain open, and that building on or deploying through it will not require Nvidia compute. Nvidia cited more than 18 million users and more than 200,000 companies. Closing is reported for 2027, subject to regulatory approval.

The deal details come from news coverage of Huang's blog post, including La Nación's wire report, and the closing timeline is reported by fewer outlets. Treat the 2027 date as an expectation rather than a fact until the companies confirm completion. A later section looks at what the acquisition could and could not change.

What the Hub is, and why "GitHub for models" is a good analogy

The Hub at huggingface.co is a collection of version-controlled repositories. According to the Hub documentation, each repository is a Git-based folder with commit history, diffs, and branches, and it can hold a model, a dataset, or a Space (an interactive demo app). Anyone can create an account and publish, and anyone can download public repositories.

The analogy to GitHub holds in three ways. Repositories belong to users or organizations, so meta-llama/... or mistralai/... tells you who published a model. People can open discussions and pull requests on a repository. And popularity is visible, so the community effectively votes on which models matter through downloads and likes.

There is one important difference. Model weights are huge files, often tens or hundreds of gigabytes, and ordinary Git handles big binary files badly. The Hub's repositories sit on a storage backend called Xet, which the docs describe as a technology that "intelligently" splits files into unique chunks so that uploads and downloads are faster. Think of it as a moving company that packs a house into identical, labeled boxes: if you rearrange only one room, you re-ship only the boxes that changed.

How big is the Hub?

Sources disagree on the exact count, which is normal for a platform that adds repositories every hour. The Hub docs say it hosts over 2 million models. Nvidia's acquisition announcement cited more than 3 million models, 500,000 datasets, and 1 million applications. Counting methods matter here: a "model" can mean an original base model, a quantized copy, or one of thousands of small fine-tunes derived from a popular base.

The safe reading is that the Hub holds millions of repositories and that most of them are derivatives rather than original research. For comparison, the 2023 TechCrunch report counted over 1 million repositories in total. The platform's size has multiplied since.

What sits inside a typical model repository

A model repository on the Hub is a folder of files. For a language model it typically contains the weights, a configuration file describing the architecture, tokenizer files (the rules for splitting text into tokens, which are chunks of characters the model reads), and a README that doubles as the model card. The table below summarizes the usual pieces.

Component	What it does	Why you care
Weights (often .safetensors)	The learned numbers that define the model	The actual "brain"; the largest files
Configuration	Layer counts, hidden sizes, and other architecture settings	Lets the library rebuild the empty model shape
Tokenizer files	Rules for turning text into token IDs	A mismatched tokenizer produces garbage output
Model card (README)	Intended use, limitations, license, training notes	Where you check whether you are allowed to use it
Metadata	Task, language, library, license tags	Powers search and filtering on the Hub

Weights alone are like a recording with no label. The configuration and tokenizer are the sheet music and the notation system that make the recording playable, and the model card is the liner note telling you where the music came from and whether you may perform it commercially.

The Transformers library: one import instead of a research repo

Transformers is the library that made Hugging Face famous, and its documentation now describes it as a "model-definition framework" for text, vision, audio, video, and multimodal models. The docs say there are over 1 million Transformers-compatible checkpoints on the Hub. A checkpoint is a saved snapshot of a trained model's weights.

The design idea is the interesting part. According to the docs, every model is built from three main classes: a configuration, a model, and a preprocessor. Because the definition is centralized, the docs claim that once a model's definition is supported in Transformers, it is compatible with most training frameworks (the docs name Axolotl, Unsloth, DeepSpeed, FSDP, and PyTorch Lightning), inference engines (vLLM, SGLang, and Text Generation Inference), and adjacent libraries such as llama.cpp and MLX.

That role explains why Transformers matters beyond its own users. It is closer to a shared dictionary than a product. When a lab releases a new model, getting its architecture into Transformers is how the rest of the open-source world learns to run it.

Three features most people use

The docs name three headline features:

• Pipeline: A simple inference class for tasks such as text generation, image segmentation, speech recognition, and document question answering.
• Trainer: A training loop that supports mixed precision, torch.compile, FlashAttention, and distributed training for PyTorch models.
• generate: Fast text generation for language and vision-language models, with streaming and several decoding strategies.

Here is what the simplest use looks like. This example loads a small sentiment classifier from the Hub and runs it on one sentence.

from transformers import pipeline

classifier = pipeline(
    "sentiment-analysis",
    model="distilbert-base-uncased-finetuned-sst-2-english",
)
print(classifier("I love Hugging Face"))
# A list with one dictionary: a label such as POSITIVE and a confidence score

The first time this runs, the library downloads the weights, configuration, and tokenizer into a local cache. Later runs reuse the cache. Larger models follow the same pattern, but they need more memory. An 8-billion-parameter model stored at 16-bit precision needs roughly 16 GB just for weights, because each parameter takes two bytes. Quantization shrinks that by storing numbers at lower precision.

Some popular models are gated, which means the publisher requires you to accept a license on the model page and authenticate before downloading. The Hub docs list gated models and gated datasets as standard features. If a download fails with an authorization error, that is usually the reason.

Why the Transformer architecture sits at the center

The library is named after the Transformer, the neural network design behind most modern language models. A Transformer lets every token in a passage weigh its relevance to every other token, a mechanism called attention. If you want the mechanics, Transformers explained simply walks through them without the math.

The rest of the toolbox

Transformers is the headline, but the ecosystem includes several other libraries, each solving one chore.

Datasets loads data from the Hub or from local files with one call. The docs highlight streaming, which lets you iterate over a dataset too large to fit on your disk or in memory. A simple analogy is the difference between downloading an entire video before watching and streaming it. Streaming gets you the first frames immediately.

Diffusers is the sibling library for image, audio, and video generation with diffusion models. It is a standard way to run models such as Stable Diffusion from Python.

PEFT and Accelerate handle two training chores. PEFT (parameter-efficient fine-tuning) implements methods such as LoRA, which trains small add-on matrices instead of updating all of a model's weights. Accelerate helps spread training across multiple GPUs. If you want the concepts behind both, the explainer on fine-tuning LLMs covers when adapting a model is worth the effort.

Text Generation Inference (TGI) is a Hugging Face inference server. The Transformers docs list it alongside vLLM and SGLang as an engine that reuses Transformers model definitions. For a comparison of the speed-focused alternatives, see what vLLM is.

The huggingface_hub client is the glue. It handles authentication, downloads, uploads, and, through its InferenceClient, calls to hosted models. Its command-line tool (hf) can log you in and list models.

A worked example: will this model fit on my machine?

The most common practical question about a Hub model is whether it will run on the hardware you have. A first estimate is simple arithmetic: multiply the parameter count by the bytes used to store each parameter. A 16-bit number takes two bytes, an 8-bit number takes one, and a 4-bit number takes half a byte.

Model size	16-bit weights	8-bit weights	4-bit weights
8 billion parameters	16 GB	8 GB	4 GB
70 billion parameters	140 GB	70 GB	35 GB

These figures cover weights only. Running a model also needs memory for the context it is reading (the key-value cache, which grows with prompt length), for activations, and for the runtime itself, so treat the table as a floor rather than a budget. The practical reading is that an 8-billion-parameter model at 4-bit precision is within reach of many consumer machines, while a 70-billion-parameter model usually needs a large GPU, several GPUs, or a high-memory workstation even when quantized. The cost is some loss of accuracy, which varies by model and method. That trade-off is why the Hub is full of quantized copies of popular models.

How a model gets onto the Hub

Publishing is as simple as downloading, which is much of the platform's appeal. A researcher trains or fine-tunes a model, saves it in the standard format with the library's save function, and pushes the folder to a repository under their account or organization. The upload carries a model card, and the author chooses the license and whether the repository is public, private, or gated.

Once the repository exists, other people can open discussions, report problems, or submit pull requests with fixes. A fine-tune of a popular base model is a new repository that usually links back to its parent in the metadata. That lineage is why a single base model can sit at the center of thousands of descendants, and why the headline model count says more about activity than about the number of distinct ideas.

Spaces: demos that anyone can click

A Space is a small web app hosted on the Hub. According to the docs, Spaces support two Python frameworks, Gradio and Streamlit, as well as static HTML pages and Docker-based apps. The practical effect is that a researcher can attach a clickable demo to a paper in minutes, and readers can try a model without installing anything.

The hardware question is how a free demo gets a GPU. Hugging Face's answer is ZeroGPU. The docs say it dynamically provides NVIDIA RTX Pro 6000 Blackwell GPUs in real time, only when a function needs one. It works like a shared taxi service rather than a leased car: you get a GPU for the seconds your function runs, then release it for someone else. The pricing page lists ZeroGPU as free at the base level, with up to 96 GB of memory available.

For apps that need a dedicated GPU, the pricing page lists hourly hardware tiers:

Spaces hardware	Price per hour
CPU Basic (2 vCPU, 16 GB)	Free
CPU Upgrade (8 vCPU, 32 GB)	$0.03
T4 small	$0.40
A10G small	$1.00
A10G large	$1.50
A100 large (80 GB)	$2.50

Prices as listed on the Hugging Face pricing page in October 2026. Check the page before budgeting, since cloud GPU prices change often.

Four ways to run a Hub model

The Hub is a library, not a server farm. Downloading a model is one thing, and running it is another. In practice there are four routes, and they trade control against effort.

1. Run it locally. Download the weights and use Transformers or another runtime on your own machine. Tools built for desktops, such as Ollama and MLX on Apple silicon, pull models from the Hub or its derivatives. You pay in hardware and electricity, and your data never leaves the machine.
2. Call Inference Providers. This is a serverless API that routes your request to partner companies. You pay as you go.
3. Deploy an Inference Endpoint. You choose a model and hardware, and Hugging Face runs a dedicated, autoscaling service for you. You pay by the hour.
4. Run it in a Space. Fine for demos, not usually the right place for production traffic.

Inference Providers in more detail

According to the Inference Providers documentation, the service gives developers access to hundreds of models through partner providers. The partner list includes Cerebras, Cohere, Fireworks, Groq, Replicate, Together, and others. A single Hugging Face token works across all of them, and the API is, in the docs' words, a drop-in replacement for the OpenAI chat completions API. You change the base URL to https://router.huggingface.co/v1 and keep the rest of your code.

The routing is configurable. By default, the system picks the provider with the highest throughput (the :fastest policy). Adding :cheapest to the model name selects the lowest price per output token, and you can also name a provider directly. The docs state there is no extra markup on provider rates, and that PRO users and Team or Enterprise organizations get monthly included credits.

The pricing page puts the PRO credit at $2 per month. That is enough to experiment, not enough to run a product.

Inference Endpoints and pricing

Inference Endpoints give you a dedicated deployment instead of a shared pool. The pricing page lists them as starting at $0.033 per hour, with example GPU rates of $0.50 per hour for a T4, $0.80 for an L4, $2.50 for an A100, and $4.50 for an H100. Dedicated hardware costs more than serverless calls at low volume. It wins when you have steady traffic, need predictable latency, or require a private deployment.

For a broader comparison of managed hosting options outside the Hugging Face ecosystem, see this comparison of Modal, Replicate, and RunPod.

What Hugging Face costs

Many of the Hub's core services are free. The Hub's public repositories, the open-source libraries, and basic CPU Spaces do not require a subscription. The paid layers are accounts, storage, and compute.

Plan or service	Price	What changes
Hub account	Free	Public models, datasets, Spaces; CPU Basic Spaces
PRO	$9 per month	8x ZeroGPU quota, priority queue, more storage, $2 monthly Inference Providers credit
Team	$20 per user per month	SSO, audit logs, access controls
Enterprise	$50 per user per month	Custom onboarding; contact sales
Storage (public repos)	From $12 per TB per month	Volume discounts at 50 TB and above
Storage (private repos)	From $18 per TB per month	Egress and CDN included

All prices come from the Hugging Face pricing page as of October 2026. Note the split between Team at $20 per user and Enterprise at $50 per user; the two are easy to confuse.

Safety: models are files, and files can be dangerous

Downloading a model means downloading a file that you will load into a program. That is a security issue, and Hugging Face has dealt with it directly.

Much of the machine learning world used PyTorch's default file format, which relies on Python's pickle serialization. Pickle can run arbitrary code when a file is loaded, so a booby-trapped model could take control of your computer. Hugging Face's answer was safetensors, a format that stores only the numbers and a small header, with no executable code. In a security audit announcement published May 23, 2023, the company said Trail of Bits had audited the library on behalf of Hugging Face, EleutherAI, and Stability AI, and that the auditors reported "no critical security flaw leading to arbitrary code execution." The same post says safetensors loads about 100 times faster on CPU than the alternatives it compares against.

Two cautions apply. First, a safe file format does not make a model's behavior safe, since a model can still be biased or inaccurate. Second, some repositories still ship pickle-based files, and the Hub documentation lists malware scanning among its security features rather than guaranteeing every file is clean. A reasonable habit is to prefer repositories with safetensors weights, to check who published the model, and to avoid enabling options that execute a repository's custom code unless you trust the author.

Licenses and model cards

Licenses are the other half of "can I use this." Every repository can declare a license in its metadata, and the licenses vary. Some models use permissive licenses such as Apache 2.0. Others, such as Meta's Llama family, use custom community licenses with conditions. Always read the model card and the license text. The model card is also where publishers are expected to describe a model's limitations and biases, which the Hub docs identify as the purpose of model cards.

Hugging Face compared with other platforms

The names below get lumped together, but they solve different problems.

Platform	Primary role	Hosts model weights?	Notes
Hugging Face	Model, dataset, and demo hub; libraries; hosted inference	Yes	The default place open models are published
GitHub	Source code hosting	Not as a primary use	Often hosts the training code that goes with a Hub model
Replicate	Hosted inference for models behind an API	Runs them for you	Also appears as a provider inside Hugging Face's routing
Kaggle	Datasets, notebooks, competitions	Datasets and notebooks	Strong for learning and competitions
Ollama	Local runner for open models	Pulls from its own library	Aimed at running models on your own machine

GitHub and Hugging Face coexist because they store different things. A training repository on GitHub produces a set of weights, and the weights usually end up on the Hub. Replicate is an interesting case. It sells hosted inference, which overlaps with Hugging Face's own hosted products, yet the Inference Providers documentation lists it as a partner. That shows how much of the ecosystem routes through the Hub.

Hub versus closed AI APIs

The deeper choice is not between Hugging Face and one competitor. It is between open weights and proprietary APIs.

With open weights from the Hub, you can inspect the model, run it on your own hardware, fine-tune it, and control where your data goes. You also take on the work of hosting, evaluating, and securing it. With a proprietary API from OpenAI, Anthropic, or Google, you get the vendor's frontier models without the operations burden, but you pay per use and accept the vendor's terms and availability.

Neither choice is universally better. Open models are often a strong fit for privacy-sensitive work, cost control at high volume, and research that requires access to weights. Proprietary models may be the better fit when you want the highest capability on difficult tasks with minimal setup. The article on open source versus proprietary AI covers the tradeoffs in more depth, and Mistral AI is a useful case study of a company that ships both open and commercial models.

Evaluating a model before you trust it

Downloads and likes show popularity, not quality. A model with a million downloads may simply be the default choice in a tutorial. Before building on a Hub model, a few checks are worth the time.

• Read the model card. Look for intended use, known limitations, and training data notes. A blank card is a warning sign.
• Check the publisher. An organization account run by the model's original lab carries more provenance than an anonymous re-upload.
• Look at the file formats. Safetensors is preferable to pickle-based files.
• Test on your own data. Public benchmarks measure what they measure. LLM evaluations explains how to build a small test set that reflects your real task.
• Check the license. Commercial use is not guaranteed.

The model cards feature is the Hub's attempt to build documentation into the culture. It works only as far as publishers fill them in, which is why the practice of reading them matters.

Getting from zero to a working model

The shortest path from nothing to a running model has four steps.

1. Install the library. Run pip install transformers in a Python environment, plus a deep learning backend such as PyTorch.
2. Pick a model. Browse huggingface.co/models and filter by task, such as text classification or summarization. Start small. A model that runs on your laptop teaches you more than a giant one that does not load.
3. Run it. Use the pipeline function shown earlier, or call a hosted model through the client.
4. Go deeper. Use the Trainer to fine-tune on your own data, or publish a Space so others can try your work.

If you would rather not run a model locally at all, the InferenceClient from the docs sends a request through Inference Providers:

from huggingface_hub import InferenceClient

client = InferenceClient()  # reads your HF token after `hf auth login`

completion = client.chat.completions.create(
    model="openai/gpt-oss-120b",
    messages=[{"role": "user", "content": "What is Hugging Face?"}],
)
print(completion.choices[0].message)

This follows the pattern in the Inference Providers quick start. You need a Hugging Face account and a token with permission to call Inference Providers, and usage beyond your included credits is billed.

Most beginners stall on model choice, not code. A useful rule is to match the model to the task rather than to the hype. Small specialized models for classification, translation, or speech recognition are often cheaper and faster than a general-purpose language model.

When Hugging Face is not the right tool

The platform is strongest for research, experimentation, fine-tuning, and self-hosted inference. It is less obviously right in a few situations.

• You need the most capable model available with no operations work. A proprietary API is usually simpler.
• You have strict latency or throughput requirements. A dedicated inference engine, tuned and quantized, may be needed. That work is possible with the libraries above, but it takes specialist knowledge.
• You cannot tolerate dependency on a single vendor. The Hub is open, but a large share of the open-model ecosystem now flows through one company. The acquisition by Nvidia makes that concentration worth watching.
• You work in a high-stakes domain. A model's availability on the Hub says nothing about whether it is validated for medical, legal, or safety-critical use.

What the Nvidia acquisition could change

Nvidia is the dominant supplier of AI training and inference chips, so a deal that places the central open-model hub under its ownership raises obvious questions. Huang's announcement addressed some of them directly: the platform will remain open, developers can choose their own models, frameworks, cloud providers, and compute, and using Hugging Face will not require Nvidia compute.

Those are statements of intent from the buyer. They are not contractual terms that outsiders can read, and the transaction had not closed when this article was updated. Wikipedia's account says closing is expected in the first half of 2027, pending regulatory approval, and that the deal includes about $11.9 billion in cash to stockholders and up to $1 billion in retention awards, though that breakdown has fewer independent sources than the headline price.

Hugging Face's earlier history provides some context. Nvidia was already a participant in the 2023 funding round, and Wikipedia reports that the company turned down a $500 million Nvidia investment offer at a $7 billion valuation in 2025. The company has been courted by large partners for years, and it has spent that time building integrations with AWS, Google Cloud, AMD, and Intel as well as Nvidia. Whether that neutrality survives ownership by a chip company is the open question, and it will be answered by behavior after closing: which hardware gets first-class support, which cloud integrations continue, and how the Hub treats competing accelerators.

Common misconceptions

"Hugging Face makes the models on its Hub." Mostly it does not. The Hub hosts models published by Meta, Mistral, universities, startups, and individuals. Hugging Face does train some of its own models, such as the small SmolLM family, but the platform's value is distribution.

"A model on the Hub is open source." Not necessarily. Many models are open-weight, meaning the numbers are downloadable, while the training data and code may not be released, and the license may restrict commercial use. The word "open" covers a spectrum.

"Downloads equal quality." Downloads equal convenience. Defaults in tutorials and popular base models collect traffic that says little about how good a model is for your task.

"Free means unlimited." The Hub's public repositories are free, but storage, hosted GPUs, and inference are metered, and the pricing page shows paid tiers for each.

"Transformers is only for text." The library's docs describe support for text, vision, audio, video, and multimodal models.

The takeaway

Hugging Face became central to open AI by solving a boring problem well: making a trained model as easy to fetch as a code package. The Hub standardized where weights live, Transformers standardized how they load, and model cards, safetensors, Spaces, and hosted inference added the surrounding infrastructure. The result is a shared commons that a student with a laptop and a lab with a thousand GPUs both use.

The commons now has a new owner in waiting. The $12.93 billion Nvidia deal is both a validation of how central the platform has become and a test of whether a neutral hub can stay neutral inside a chip company. The practical advice for builders is conservative: use the Hub, prefer safetensors, read model cards and licenses, keep your deployment code portable, and watch what happens after the deal closes.

Frequently Asked Questions

Q: Is Hugging Face free? A: Much of it is. Public Hub repositories, the open-source libraries, and basic CPU Spaces are free. Paid items include the PRO plan ($9 per month), Team ($20 per user per month), Enterprise ($50 per user per month), private storage, GPU Spaces, and Inference Endpoints, according to the pricing page.

Q: Who founded Hugging Face? A: Clément Delangue, Julien Chaumond, and Thomas Wolf founded it in 2016 in New York City. It began as a chatbot app for teenagers before shifting to machine learning tools.

Q: What is the Transformers library? A: It is Hugging Face's open-source library for loading, running, and training pretrained models. Its docs describe it as a model-definition framework for text, vision, audio, video, and multimodal models, and say the Hub holds over 1 million compatible checkpoints.

Q: How is Hugging Face different from GitHub? A: GitHub is built for source code. Hugging Face is built for large model files, datasets, and demo apps, with storage designed for big binaries and metadata such as licenses and tasks. They complement each other, since training code often lives on GitHub and the resulting weights on the Hub.

Q: Can I use Hugging Face models commercially? A: It depends on each model's license. Some use permissive licenses such as Apache 2.0, while others, such as the Llama family, use custom licenses with conditions. Read the license on the model card before shipping a product.

Q: What is a Hugging Face Space? A: A Space is a hosted web app on the Hub, built with Gradio, Streamlit, static HTML, or Docker. It lets a publisher give people a clickable demo of a model. Basic CPU hosting is free, and GPU hardware is billed hourly or provided dynamically through ZeroGPU.

Q: Did Nvidia buy Hugging Face? A: Nvidia announced an agreement on September 3, 2026 to acquire it for $12.93 billion. Closing was reported as expected in 2027, subject to regulatory approval, so the deal had not completed at the time of this update.

Sources

• Hugging Face Hub documentation
• Hugging Face pricing page
• Transformers documentation
• Inference Providers documentation
• Wolf et al., "HuggingFace's Transformers: State-of-the-art Natural Language Processing" (arXiv:1910.03771)
• Hugging Face blog: Audit shows that safetensors is safe and ready to become the default
• TechCrunch: Hugging Face raises $235M (August 24, 2023)
• La Nación: Nvidia buying Hugging Face for $13 billion (September 3, 2026)
• Wikipedia: Hugging Face