# MetaCLIP 2 is a worldwide CLIP recipe, and the repo is a data and training project rather than a library

> Meta's open source CLIP work moved from English-centric training to a multilingual data curation and training recipe, with distilled variants, published checkpoints and code for the curation tools. The packaging in this repository is inherited from OpenCLIP, so what you install and what the models are are two separate things.

**facebookresearch/MetaCLIP** — NeurIPS 2025 Spotlight; ICLR2024 Spotlight; CVPR 2024; EMNLP 2024

- Repository: https://github.com/facebookresearch/MetaCLIP
- Stars: 1,857 · Forks: 81
- Language: Python
- License: NOASSERTION
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/facebookresearch-metaclip

## The argument is about data, not about the encoder

MetaCLIP 2 is described as taking the next step after years of English-centric CLIP development, scaling CLIP to worldwide data. The README names two problems it addresses: large-scale non-English data curation pipelines are largely undeveloped, and there is the curse of multilinguality, where English performance often degrades in a multilingual CLIP compared to an English-only CLIP.

The claim is that English and non-English worlds can mutually benefit, and the result is described as state of the art multilingual performance. That framing explains the shape of the repository. This is not a new model architecture. It is a data and training project.

The lineage is in the citations. The first paper is Demystifying CLIP Data, accepted at ICLR 2024 as a spotlight, and the arXiv identifier 2309.16671 is on the README. The follow-up, Meta CLIP 2: A Worldwide Scaling Recipe, is arXiv 2507.22062, accepted at NeurIPS 2025 as a spotlight. Between them sit MoDE, CLIP Data Experts via Clustering, accepted at CVPR 2024, and Altogether, Image Captioning via Re-aligning Alt-text, accepted at EMNLP 2024.

Four papers, each with code in a subdirectory of this repository, is the shape of a project that treats the curation pipeline as the contribution. If you are looking for a new model class, this is the wrong repository. If you want to understand how a 29 billion pair training set is built and filtered, it is exactly the right one.

## The checkpoints come in four sizes, with a distilled line

The published models are the fastest way to use this work, and the table is explicit about what pairs with what.

For Meta CLIP 2, four checkpoints are listed, all using the `metaclip2_worldwide` pretrained tag, all with the `facebook/xlm-v-base` tokenizer, all trained on 29B seen pairs, and all with an Online Curation data card. The architectures are `ViT-H-14-quickgelu-worldwide` and `ViT-H-14-378-worldwide` at 224 and 378 resolution, and `ViT-bigG-14-worldwide` and `ViT-bigG-14-378-worldwide` at 224 and 378 resolution.

The reported metric is CVQA-LOCAL zero-shot accuracy, and the numbers go from 57.4 for the ViT-H quickgelu at 224 up to 62.0 for ViT-bigG at 378. The same table lists a distilled line, where `ViT-S-16-worldwide` at 224 reports 46.9, which is the compact option for latency sensitive work.

Two details are worth flagging. The 378 resolution variants are separate checkpoints rather than a flag, so choosing a resolution means choosing a weight file. And the tokenizer column is not optional detail, since a mismatched tokenizer with a checkpoint produces embeddings that are silently wrong rather than an error.

The distilled models, the training code and the evaluation code for Meta CLIP 2 all went out together on 2025-11-21 according to the updates list, and the paper was on open_clip and Hugging Face by 2025-08-25, so the weights are also available through the ecosystems most people already have installed.

## Two ways to load a model, one of them borrowed from another project

The quick start offers two paths, and picking between them is a decision about which codebase you want to live in.

The first is the mini_clip implementation that lives in this repository.

```python
import torch
from PIL import Image
from src.mini_clip.factory import create_model_and_transforms, get_tokenizer

model, _, preprocess = create_model_and_transforms('ViT-H-14-quickgelu-worldwide@WorldWideCLIP', pretrained='metaclip2_worldwide')
tokenize = get_tokenizer("facebook/xlm-v-base")

image = preprocess(Image.open("docs/CLIP.png")).unsqueeze(0)
text = tokenize(["a diagram", "a dog", "a cat"])

with torch.no_grad():
    image_features = model.encode_image(image)
    text_features = model.encode_text(text)
    image_features /= image_features.norm(dim=-1, keepdim=True)
    text_features /= text_features.norm(dim=-1, keepdim=True)

    text_probs = (100.0 * image_features @ text_features.T).softmax(dim=-1)
```

The second is Hugging Face transformers, with `AutoProcessor` and `AutoModel` loading a checkpoint by repository name.

```python
from PIL import Image
from transformers import AutoProcessor, AutoModel

processor = AutoProcessor.from_pretrained("facebook/metaclip-b32-400m")
model = AutoModel.from_pretrained("facebook/metaclip-b32-400m")

image = Image.open("docs/CLIP.png")
inputs = processor(text=["a diagram", "a dog", "a cat"], images=image, return_tensors="pt", padding=True)

with torch.no_grad():
  outputs = model(**inputs)
  logits_per_image = outputs.logits_per_image
  text_probs = logits_per_image.softmax(dim=-1)
```

The commented lines in that second example show the Meta CLIP 2 checkpoint names for the transformers path, so the same model family is reachable both ways.

The packaging detail catches the eye. The `setup.py` in this repository is OpenCLIP's own file: it declares the package name as `open_clip_torch`, the URL as the mlfoundations open_clip repository, the license classifier as Apache, and it reads the version from `src/open_clip/version.py`. The repository root also carries a separate `openclip_LICENSE` file. So the installable package here is a vendored OpenCLIP, and the project's own weights and data are distributed as files and directories rather than as a Python package with a clean boundary.

## The curation tools are the actual research contribution

The repository layout shows where the research code lives, and it is spread across several subdirectories that each correspond to a paper.

`metaclip/` holds the code for building metadata, which was released in January 2024. `mode/` holds the MoDE code, the CLIP Data Experts via Clustering work from CVPR 2024. `altogether/` holds the image captioning code from EMNLP 2024, which is the synthetic caption re-aligning approach used for Meta CLIP 1.2. The `clipeval/` directory is the evaluation harness, `apps/` holds application code, `configs/` holds training configurations, and `tests/` holds the test suite.

The `submit.py` file at the root and the `Makefile` with install, install-dev and test targets are the developer entry points, and the test target runs pytest over the `tests` directory.

The metadata building step is the part worth understanding, because it is the difference between a research repo and a model zoo. CLIP training data is enormous, and the quality of a checkpoint depends on filtering it. The MoDE paper describes CLIP Data Experts via Clustering, which is a method of assigning data to expert models so that filtering can be done by specialised judges rather than one general model. The metadata code is the machinery that produces those judgements in the first place.

For a reader, this is the argument for spending time in the repository rather than only downloading weights. The published checkpoints are a fixed set of outcomes from a pipeline you can read, and the pipeline is where the interesting engineering lives.

## Licence, model openness and the version history

The GitHub metadata reports a licence that GitHub could not classify, so the authoritative terms are in the LICENSE file. The project is published by Meta, and the `setup.py` carries the Meta Platforms copyright header. The presence of a separate `openclip_LICENSE` at the root reflects the fact that the vendored OpenCLIP code carries its own Apache licence, which is the right thing to do and is worth checking in the file itself rather than assuming.

There is also a `HISTORY.md` at the root alongside the README's own dated updates list, and the two tell the same story. The initial release was on 2023-09-28, Meta CLIP 1.1 with ViT-G/14 came in December 2023, v0.1 was tagged in August 2024, Meta CLIP 1.2 with ViT-H/14 and Altogether synthetic captions came in December 2024, and the Meta CLIP 2 paper landed in July 2025 with the checkpoints following in August and the training and evaluation code in November.

The release tags are v0.2 from October 2024, v0.3 from November 2025, and v0.3.1 from 2026-08-11, which is also the date of the last push to the repository. The repository is not archived.

The version scheme staying below 1.0 across a multi-year research project is normal for this kind of repository, and it is a reminder that the code is a research artifact with an accompanying paper rather than a supported library with a compatibility promise. The checkpoints, by contrast, are static files with a published licence and a published evaluation number, and that is the part with a longer useful life.

## Conclusion

Adopt the MetaCLIP checkpoints if you need a strong multilingual image-text encoder, especially with a non-English language, and you would rather load a published weight file than run a training pipeline. Do not adopt this repository as your application dependency, because the package metadata here is OpenCLIP's own setup file and the useful artifacts are the data, the curation code and the checkpoints. Verify first that the licence covering the code and the licence covering the curated data and weights are both acceptable to you, that the tokenizer you pair with a checkpoint matches the table entry, and that the zero-shot accuracy figure for the checkpoint you plan to use was measured on the evaluation you care about.

## FAQ

### What is MetaCLIP 2 and what problem does it address?

It is Meta's open source CLIP project, and Meta CLIP 2 scales CLIP to worldwide data. The README names two problems: large-scale non-English data curation pipelines are largely undeveloped, and English performance often degrades in a multilingual CLIP compared to an English-only one.

### How do I load a MetaCLIP 2 model with Hugging Face transformers?

Use AutoProcessor.from_pretrained and AutoModel.from_pretrained with the checkpoint name, for example facebook/metaclip-2-worldwide-huge-quickgelu, then pass text and images to the processor and read logits_per_image from the model output.

### Which tokenizer goes with the MetaCLIP 2 checkpoints?

The Meta CLIP 2 and Meta CLIP 2 Distilled tables list facebook/xlm-v-base as the tokenizer for every listed checkpoint. The MiniCLIP path loads it with get_tokenizer("facebook/xlm-v-base").

### Which MetaCLIP checkpoints are available and what are their sizes?

Meta CLIP 2 lists ViT-H-14-quickgelu, ViT-H-14-378, ViT-bigG-14 and ViT-bigG-14-378, all with the metaclip2_worldwide pretrained tag, 29B seen pairs, 224 or 378 resolution, and reported CVQA-LOCAL zero-shot accuracy from 57.4 to 62.0. A distilled line includes ViT-S-16 at 224 reporting 46.9.

### What licence applies to the MetaCLIP code and weights?

The repository licence is one GitHub could not classify, so the LICENSE file is authoritative. The vendored OpenCLIP code in this repository is packaged with its own openclip_LICENSE file, and the setup.py carries an Apache licence classifier for that code.

## Sources

- [facebookresearch/MetaCLIP on GitHub](https://github.com/facebookresearch/MetaCLIP)
- [Issues](https://github.com/facebookresearch/MetaCLIP/issues)
- [README](https://github.com/facebookresearch/MetaCLIP/blob/main/README.md)
- [Releases](https://github.com/facebookresearch/MetaCLIP/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/facebookresearch-metaclip