Every open model, one place

Mixture of experts, and the clearest case for two counts: 671B has to fit, 37B runs.

Mixture of experts. Needs datacentre memory, then generates at a 22B model's pace.

Dense and large, with the long window the earlier 70B did not have.

Dense, and about the largest that fits one 48 GB card at full precision.

A reasoning model: it emits far more tokens per answer, so cost per token dominates.

The local sweet spot: 30B of weights to hold, 3.3B of work per token.

Dense, long window, and takes images as well as text.

Sized to fit a single 32 GB card once quantised, which is what it does.

Small and dense, with a short window that keeps the cache cheap.

The 27B model's smaller sibling. Fits a 16 GB card at full precision.

Long context at a size a desktop card holds without quantising.

Small enough that the context cache, not the weights, is the larger half.

Code model at the size where a 48 GB card stops being optional.

Large and long-context together, which is the most demanding pair.

The original large one. Multi-card at full precision on anything but an H200.

Mixture of experts. All weights load even though two of eight run per token.

Larger code model. Wants a 48 GB card or better at full precision.

Mid-size. The awkward one that does not fit 24 GB at full precision.

Code completion at a size that fits one mid-range card.

Images in, text out. The vision tower adds to the weights below.

A small general chat model. The usual first thing anyone serves.

Very long context. The cache, not the weights, is what costs here.

Small, long context for its size.

Small enough for a consumer card, with a long window.

Embeddings. Tiny, and throughput-bound rather than memory-bound.

The largest open Llama. A datacentre of cards even quantised.

The 70B that gained the long window Llama 3 lacked.

Long context at a size a desktop card holds. A common default.

Small and long-context, sized for a laptop.

About as small as a useful chat model gets.

Images in, at the large end. The vision tower adds to the weights.

The smaller multimodal Llama. Text and images in.

Dense 32B, about the largest that fits one 48 GB card at full precision.

Mid-size dense chat with a long window.

Small dense chat for a consumer card.

Tiny, runs almost anywhere.

The smallest of the family. The cache outweighs the weights.

Code model at a size a single mid-range card holds.

Small code model, long context for its size.

Large vision-language model. Reads images and documents.

Mistral's largest open weights, dense.

Mixture of experts: 141B load, 39B run per token.

A 12B with a long window, built with NVIDIA.

Mistral's code model, sized for one 32 GB card.

Mistral's multimodal 12B. Images and text in.

Dense 9B with a short, cheap window.

Small dense chat, runs on almost anything.

Mixture of experts: 42B load, 6.6B run per token.

The larger dense Phi, long context.

Mixture of experts: 671B load, 37B run. Datacentre memory to hold.

Cohere's larger open model, built for retrieval and tools.

The 35B Command R, long context.

01.AI's 34B dense chat model.

Databricks' mixture of experts: 132B load, 36B run per token.

Open code model trained on permissively-licensed source.

Multilingual embeddings with a long input window.

Small open embeddings, long input for its size.