BERT Base Uncased: Specs, How to Run It, and Why It's Still Trending in 2026

google-bert/bert-base-uncased is Google's 110 million parameter masked-language model, first published alongside the 2018 BERT paper and now sitting at 48.8 million downloads on Hugging Face. It fills in masked words, produces text embeddings, runs fine on a CPU, and is Apache 2.0 licensed. Install it with pip install transformers and load it with the fill-mask pipeline in three lines.

Written by Priya Raghunathan, local-AI hardware reviewer. I check parameter counts and hardware requirements against the primary source before recommending an install path, whether the model is three days old or eight years old.

Why a 2018 model is trending in 2026

bert-base-uncased just re-entered Hugging Face's overall trending top 20, which is unusual for a model this old. It isn't newly popular, it's durably popular: 3,085 likes and 48,848,285 downloads at time of writing, plus 40,042 stars on the google-research/bert GitHub repo. BERT isn't a chat model, so it doesn't compete on the benchmarks that make headlines. What it does is sit quietly inside other people's pipelines as a text encoder: it's the component behind the demo Space with the most links to this model, mediasynthesismuseum/latentdiffusion (513 likes), and it shows up the same way inside Salesforce's BLIP, IDEA-Research's Grounded-SAM, and Microsoft's HuggingGPT. When a project needs a small, reliable, well-understood text encoder, this is still the default answer.

Specs at a glance

Hardware: this one doesn't need a GPU

At 110 million parameters, bert-base-uncased loads in roughly 440 MB at full float32 precision, well under 1 GB. That's small enough to run inference on a laptop CPU with no quantization and no GPU, which is a different calculus than the multi-billion parameter causal language models most of this site's hardware guides cover. If you're used to checking VRAM tiers before downloading a model, you can skip that step here.

Run it: fill-mask in three lines

The fastest way to try the model is the pipeline API, which downloads the weights and tokenizer and runs masked-word prediction directly.

from transformers import pipeline

unmasker = pipeline("fill-mask", model="google-bert/bert-base-uncased")
unmasker("Hello I'm a [MASK] model.")

The top prediction for that exact prompt, per the model card, is "fashion" with a 10.7% confidence score, followed by "role", "new", "super" and "fine". [MASK] is the literal token BERT expects; swap in your own sentence and mask position to test other completions.

Get embeddings instead of predictions

For downstream tasks like classification or semantic search, you typically want the model's hidden states rather than a fill-mask prediction. This loads the base BertModel and returns a tensor of features for the input text.

from transformers import BertTokenizer, BertModel

tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")
model = BertModel.from_pretrained("google-bert/bert-base-uncased")

text = "Replace me by any text you'd like."
encoded_input = tokenizer(text, return_tensors="pt")
output = model(**encoded_input)

Swap BertModel and return_tensors="pt" for TFBertModel and return_tensors="tf" if you're on TensorFlow instead of PyTorch; both are supported directly by the transformers library.

How it was trained

BERT base uncased was pretrained on BookCorpus, a collection of 11,038 unpublished books, plus English Wikipedia with lists, tables and headers stripped out. Training ran for one million steps at batch size 256 on 4 Cloud TPUs in a pod configuration, 16 TPU chips total, with 90% of steps capped at 128-token sequences and the remainder at 512 tokens.

Benchmark results: GLUE

The model card reports fine-tuned GLUE test scores rather than zero-shot numbers, since BERT is meant to be fine-tuned per task rather than prompted directly.

Known bias, straight from the model card

Hugging Face's model card is unusually direct about this: despite fairly neutral training data, BERT's predictions carry gender bias, and that bias carries into every fine-tuned version built on top of it.

"The man worked as a carpenter" ranks first for the masked prompt about a man's occupation, while "the woman worked as a nurse" ranks first, followed by waitress and maid, for the equivalent prompt about a woman.

License and who it's for

Both the model weights and the google-research/bert GitHub repo are Apache 2.0, with no revenue cap or attribution requirement. That, combined with a tiny footprint and eight years of tooling built around it, is the practical reason it keeps showing up: it's a safe default text encoder for projects that don't want to depend on a large, frequently-updated model, not a choice for anyone who needs a conversational assistant or a code generator.

FAQ

What is bert-base-uncased used for?

Filling in masked words, producing text embeddings for downstream tasks, and serving as the text encoder inside larger pipelines like image generation or captioning models. It's rarely used as-is for chat or text generation; those tasks are better served by autoregressive models like GPT-style architectures.

Does bert-base-uncased need a GPU?

No. At 110 million parameters and roughly 440 MB in float32, it runs inference on a laptop CPU without quantization. A GPU speeds up batch processing but isn't required to try the model.

Why is an eight-year-old model trending in 2026?

It re-entered Hugging Face's overall trending top 20 on download and usage volume, not on a new release. It's the text encoder inside more than 120 public Spaces, including well-known ones like Salesforce's BLIP and Microsoft's HuggingGPT, which keeps its download count climbing years after its last update.

Is bert-base-uncased free to use commercially?

Yes, it's licensed Apache 2.0 with no revenue threshold and no required attribution, for both the Hugging Face weights and the original GitHub repo.

Where to go from here

• Comparing model sizes for a local project? See best GGUF models by VRAM tier for how BERT's footprint stacks up against causal language models.
• New to quantization formats for larger models? Read the GGUF vs MLX vs NVFP4 explainer.