Best Masked Language Models to Run Locally in 2026

Quick Answer

LFM2.5-Encoder-350M (LiquidAI) is the top pick as of September 2026 for its recent July release and 128K-token context [6]. In order, the ranking is LFM2.5-Encoder-350M (LiquidAI), LFM2.5-Encoder-230M (LiquidAI), esm2_t33_650M_UR50D (facebook), esm2_t6_8M_UR50D (facebook), bert-base-uncased (google-bert), xlm-roberta-base (FacebookAI), roberta-base (FacebookAI), and distilbert-base-uncased (distilbert) [6][7].

Key Takeaways

• LiquidAI’s LFM2.5-Encoder-350M provisionally leads for its recent publication on July 27, 2026, and 128K-token context; its 354M parameters do not establish a performance advantage, and it has no public benchmark yet.[6]
• LiquidAI’s LFM2.5-Encoder-230M offers 230M parameters with the same 128K-token context and July 27, 2026 publication date; both LiquidAI encoders use the lfm1.0 license.[6][7]
• The recent-release pool is too thin, so the shortlist includes older, newest-available fallbacks: facebook’s esm2_t33_650M_UR50D and esm2_t6_8M_UR50D were published in September 2022 and provide 652M and 8M parameters respectively, each with a 1,026-token context and MIT license.[4][5]
• google-bert’s bert-base-uncased provides 110M parameters, a 512-token context and Apache-2.0 licensing; FacebookAI’s xlm-roberta-base provides 279M parameters, a 514-token context and MIT licensing.[8][10]
• FacebookAI’s roberta-base provides 125M parameters and a 514-token context under MIT; distilbert’s distilbert-base-uncased provides 67M parameters and a 512-token context under Apache-2.0.[14][12]
• Local memory planning remains incomplete: the LiquidAI encoders list F32 weights of 1.4 GB and 0.9 GB respectively, but no verified 4-bit memory figures or dated public benchmark scores are provided.[6][7]

How do local masked language models compare on specifications and dated benchmarks?

Which masked language models should you consider running locally?

1. LFM2.5-Encoder-350M

LFM2.5-Encoder-350M by LiquidAI ranks first on recency, with downloads breaking its tie with LiquidAI’s LFM2.5-Encoder-230M—not on demonstrated benchmark superiority.[6][7] Published on Hugging Face on July 27, 2026, it has 354 million parameters, a 128K-token context window and the lfm1.0 license.[6] The selection includes older models because too few candidates meet the recent-release requirement; LiquidAI’s encoder falls within the requested 12-month window.[6] Its benchmark status is no public benchmark yet.

Consider it for local evaluation when your intended workload needs a long context window, while validating task quality before adoption. Published F32 weights occupy 1.4 GB, but that figure does not establish total RAM or VRAM requirements.[6] A verified 4-bit memory requirement is unavailable, so no specific hardware configuration can be recommended from the published specifications alone.[6] Measure memory consumption at your intended input length before committing hardware. The central caveat is that its ranking does not establish a measured quality advantage.

2. LFM2.5-Encoder-230M

LFM2.5-Encoder-230M by LiquidAI ranks second in this selection: its Hugging Face publication date matches LFM2.5-Encoder-350M by LiquidAI at July 27, 2026, with the lower download count used only to break that tie.[6][7] Both sit ahead of the older candidates under the recency rule; the placement does not establish a performance advantage. Benchmark status: no public benchmark yet.

The model has 230 million parameters, a 128K-token context window and the lfm1.0 license.[7] Its listed F32 weights occupy 0.9 GB.[7] Local hardware requirements remain unverified: the weight size does not establish total runtime memory, and a minimum RAM or VRAM configuration is not specified. Memory at four-bit precision is also unspecified.

Consider it for local evaluation when the advertised context window matches your workload and you prefer fewer parameters than its sibling.[6][7] The caveat is validation: confirm runtime compatibility and memory use on your hardware before committing to deployment.

3. esm2_t33_650M_UR50D

esm2_t33_650M_UR50D by facebook ranks third here by publication recency, rather than demonstrated benchmark performance: its Hugging Face publication date is September 27, 2022.[4] The recent-release pool is too small, so older available candidates remain included. Its status is “no public benchmark yet”; no benchmark score or benchmark date is available to establish a performance advantage.

The checkpoint has 652 million parameters, a context length of 1,026 tokens, and published F32 weights totaling 2.6 GB.[4] For local hardware planning, treat that file size as a weight-storage figure, not a confirmed RAM or VRAM requirement. A hardware minimum and a verified 4-bit memory footprint are not specified.[4]

Consider this checkpoint when its MIT license and 1,026-token context fit your application.[4] Those are concrete selection criteria; a task-specific “best” designation is not established. The practical caveat is that the published weight size alone cannot establish whether your intended local setup will run it.

4. esm2_t6_8M_UR50D

esm2_t6_8M_UR50D by facebook occupies the fourth slot as a compact legacy option, with 8M parameters and a context limit of 1,026 tokens.[5] Its placement should be read as an editorial selection: no public benchmark yet establishes its performance against the other candidates. Hugging Face first publication was 2022-09-26, making its inclusion an exception to the recent-release requirement.[5]

The MIT-licensed model is a candidate for local evaluation when a small parameter count matters.[5] Quantized memory consumption and a verified minimum hardware configuration are unavailable. Avoid treating the parameter count alone as a RAM or VRAM requirement; a local deployment still needs its actual memory use checked before choosing hardware.

Consider it for experiments that fit within its 1,026-token context.[5] The practical caveat is uncertainty: neither benchmark results nor measured local memory requirements establish whether it suits your workload.

5. bert-base-uncased

bert-base-uncased by google-bert ranks here as an older fallback behind recent candidates such as LiquidAI’s LFM2.5-Encoder-350M and LFM2.5-Encoder-230M, which were first published on Hugging Face on July 27, 2026.[6][7][8] Its inclusion reflects the limited recent options in this category, rather than demonstrated benchmark superiority. Benchmark status: no public benchmark yet.

The model has 110M parameters, a context length of 512 tokens, and an Apache-2.0 license.[8] Listed F32 weights occupy 0.4 GB; treat that as a weight-storage figure, not a complete hardware requirement.[8] Total runtime RAM or VRAM and a verified 4-bit memory footprint are unspecified.[8] Check memory consumption with your intended runtime before committing to hardware.

Consider it for a local masked-token baseline when inputs fit its context window. The practical caveat is that its Hugging Face first-publication date is March 2, 2022, so it belongs among the older available options, not recent releases.[8]

6. xlm-roberta-base

xlm-roberta-base from FacebookAI occupies this position as an older fallback for cross-lingual language understanding, rather than a demonstrated benchmark winner.[10][11] Its Hugging Face publication date is March 2, 2022, so it falls outside the requested release window; the shortlist includes older entries because recent candidates are limited.[10] Benchmark status: no public benchmark yet; a dated score is unavailable for a performance comparison.

The model has 279 million parameters, a context length of 514 tokens, and an MIT license.[10] Published full-precision F32 weights occupy 1.1 GB.[10] For local hardware planning, treat that weight size as a starting point, not a complete RAM or VRAM requirement. A verified memory requirement for quantized operation is unavailable, so a specific minimum hardware configuration would be premature.

Cross-lingual representation learning is its relevant use case.[11] The practical caveat is the 514-token context limit: check whether your intended inputs fit before choosing it for local deployment.[10]

7. roberta-base

roberta-base by FacebookAI ranks #7 as an older fallback in a category with too few recent releases; its Hugging Face publication date is March 2, 2022.[14] The shortlist therefore includes older available models. LiquidAI’s LFM2.5-Encoder-350M and LFM2.5-Encoder-230M were published on July 27, 2026, and take priority under the recency rule.[6][7] The benchmark status here is “no public benchmark yet”; this placement does not establish a performance advantage.

The model has 125 million parameters, a context limit of 514 tokens, and F32 weights listed at 0.5 GB.[14] Local hardware must accommodate the weights plus runtime memory, so the weight size alone cannot establish whether a particular machine will suffice. Quantized memory requirements and a minimum RAM or VRAM configuration are unspecified.

Consider roberta-base for an existing RoBERTa workflow where compatibility matters. The MIT license supports that practical evaluation.[14] The main caveat is the 514-token context limit: check input lengths before committing to local deployment.[14]

8. distilbert-base-uncased

distilbert-base-uncased by distilbert ranks here as an older fallback in a category with too few recent releases. Its Hugging Face publication date is March 2, 2022 [12]. The benchmark status is “no public benchmark yet,” with no score or benchmark date available to establish a performance advantage over newer candidates.

The model has 67 million parameters, a context length of 512 tokens, and an F32 checkpoint listed at 0.3 GB [12]. Its license is Apache-2.0 [12]. Consider it for local masked-language-model evaluation when the published checkpoint size and licensing fit your project; keep input sequences within the documented context limit.

For hardware planning, treat the checkpoint size as a starting point, not a total RAM or VRAM requirement. Memory at four-bit precision and minimum hardware requirements are unspecified. Verify runtime memory on your intended machine before deployment. The main caveat is the limited context window, which constrains how much text each input can contain [12].

Why include older models when recent releases are limited?

Older models belong in the comparison because recent releases are limited, leaving a narrow shortlist if older options are excluded. LiquidAI’s LFM2.5-Encoder-350M (LiquidAI) and LFM2.5-Encoder-230M (LiquidAI) were both first published on Hugging Face on July 27, 2026.[6][7] Older entries fill gaps in coverage; their inclusion does not establish that they outperform recent releases.

The comparison therefore includes the newest available family entries alongside older fallbacks, with publication dates made explicit. A Hugging Face publication date should be labelled as such: google-bert’s bert-base-uncased (google-bert) was first published there on March 2, 2022,[8] while its accompanying BERT paper dates to October 11, 2018.[9]

Older options also provide concrete deployment tradeoffs. FacebookAI’s xlm-roberta-base (FacebookAI) lists 279 million parameters, a context length of 514 tokens and an MIT license.[10] The google-bert model lists 110 million parameters, a context length of 512 tokens and an Apache-2.0 license.[8] Those specifications give engineers useful comparison points without implying a quality ranking.

Recency must still govern inclusion and ordering. Recent entries without a published score should read “no public benchmark yet.” An older model’s score must never move it above a newer unscored entry, and download counts should break otherwise equal ties rather than establish technical superiority. Older models broaden the practical shortlist; they do not substitute popularity for demonstrated capability.

Which quantized memory requirements remain unreported?

Quantized memory requirements remain unreported for every candidate: none has a stated 4-bit weight footprint or measured RAM or VRAM requirement for quantized inference.[1][3][4][5][6][7][8][10][12][14] A practical hardware comparison therefore has an unresolved memory column.

LiquidAI’s LFM2.5-Encoder-350M (LiquidAI) lists F32 weights of 1.4 GB,[6] while LiquidAI’s LFM2.5-Encoder-230M (LiquidAI) lists 0.9 GB.[7] Neither entry reports quantized weight storage, runtime memory, or a quantization configuration associated with a measured memory result.[6][7]

For google-bert’s bert-base-uncased (google-bert), the reported F32 weight size is 0.4 GB.[8] FacebookAI’s xlm-roberta-base (FacebookAI) lists 1.1 GB,[10] FacebookAI’s roberta-base (FacebookAI) lists 0.5 GB,[14] and distilbert’s distilbert-base-uncased (distilbert) lists 0.3 GB.[12] Those figures describe the reported floating-point weights; quantized memory requirements remain unspecified for each model.[8][10][12][14]

For facebook’s esm2_t33_650M_UR50D (facebook), the reported F32 weight size is 2.6 GB.[4] The entry for facebook’s esm2_t6_8M_UR50D (facebook) displays 0.0 GB for F32 weights.[5] Neither figure supplies a measured quantized footprint or a runtime memory requirement.[4][5]

Microsoft’s microsoft/mdeberta-v3-base and Microsoft’s microsoft/deberta-v3-base also lack reported quantized memory requirements.[1][3] Hardware planning for these candidates still needs quantized weight size and measured inference memory tied to a specified configuration. Treat those fields as unknown; the listed weight figures do not establish a supported RAM or VRAM budget for quantized execution.

How should you choose a model with no public benchmark yet?

Choose a model with no public benchmark yet by checking its license, context limit and hardware requirements, then evaluating it on examples from your own workload. Treat missing scores as uncertainty, and make your selection provisional until local results justify it.

LiquidAI’s LFM2.5-Encoder-350M and LFM2.5-Encoder-230M were first published on Hugging Face on July 27, 2026; both have no public benchmark yet.[6][7] Their listed context limits are 128K tokens, and both use the lfm1.0 license.[6][7] Check the license terms against your intended use before investing in integration.

Start your hardware assessment with the published weight sizes: LFM2.5-Encoder-350M lists 354M parameters and F32 weights of 1.4 GB; LFM2.5-Encoder-230M lists 230M parameters and F32 weights of 0.9 GB.[6][7] Quantized runtime memory remains unverified. Measure memory with your intended runtime, input lengths and batch settings before committing to a deployment.

Build a representative evaluation set with expected outputs and explicit acceptance criteria. Compare task accuracy, latency and peak memory under consistent conditions. Include difficult examples and inputs near your intended length limit.

Keep benchmark status separate from your deployment decision. Label model-card results “self-reported,” and retain “no public benchmark yet” until a public result exists. Use popularity only to break an otherwise unresolved tie; download counts cannot establish task quality.

Frequently Asked Questions

Which masked language model should I evaluate first for local use?

LiquidAI’s LFM2.5-Encoder-350M (LiquidAI) takes the first evaluation slot because it shares the newest publication date, 2026-07-27, with LiquidAI’s LFM2.5-Encoder-230M (LiquidAI), with downloads used only to break that tie.[6][7] Both have no public benchmark yet, so the ordering does not establish a performance winner. Their parameter counts are 354M and 230M respectively, and both list a 128K-token context.[6][7]

Are all the candidates recent releases?

The family has too few recent releases to fill the shortlist, so the newest available candidates are included alongside older entries. LiquidAI’s encoder candidates were first published on Hugging Face on 2026-07-27.[6][7] By comparison, facebook’s esm2_t33_650M_UR50D (facebook) was first published there on 2022-09-27, and facebook’s esm2_t6_8M_UR50D (facebook) on 2022-09-26.[4][5] Those dates describe repository publication, rather than demonstrating a new model generation.

How much memory do I need to run these models locally?

A verified quantized-memory requirement is unavailable for a hardware recommendation. LFM2.5-Encoder-350M (LiquidAI) lists F32 weights of 1.4 GB, while LFM2.5-Encoder-230M (LiquidAI) lists 0.9 GB.[6][7] google-bert’s bert-base-uncased (google-bert) lists F32 weights of 0.4 GB, and distilbert’s distilbert-base-uncased (distilbert) lists 0.3 GB.[8][12] Those storage figures do not establish memory requirements at 4-bit precision; quantized runtime memory remains unverified.[6][7][8][12]

Which candidates support long inputs?

LFM2.5-Encoder-350M (LiquidAI) and LFM2.5-Encoder-230M (LiquidAI) each list a 128K-token context.[6][7] Microsoft’s microsoft/mdeberta-v3-base and microsoft/deberta-v3-base each list 512 tokens.[1][3] FacebookAI’s xlm-roberta-base (FacebookAI) and roberta-base (FacebookAI) each list 514 tokens.[10][14] Both facebook ESM candidates list 1,026 tokens.[4][5] Use those published limits to shortlist candidates for your input length; the context specifications alone do not establish comparative task quality.

What licenses do these local models use?

LFM2.5-Encoder-350M (LiquidAI) and LFM2.5-Encoder-230M (LiquidAI) list the lfm1.0 license.[6][7] The Microsoft candidates, facebook ESM candidates, xlm-roberta-base (FacebookAI) and roberta-base (FacebookAI) list MIT.[1][3][4][5][10][14] bert-base-uncased (google-bert) and distilbert-base-uncased (distilbert) list Apache-2.0.[8][12] Check the applicable license text against your intended deployment before selecting a model. Local execution is a deployment choice; treat the model’s license as a separate selection requirement.

Do benchmark scores justify choosing the newer LiquidAI encoders?

For LFM2.5-Encoder-350M (LiquidAI) and LFM2.5-Encoder-230M (LiquidAI), the benchmark status is “no public benchmark yet” at the 2026-09-25 snapshot.[6][7] Neither has a dated benchmark result to quote here. Their shared context specification and different parameter counts support a specification comparison, but do not demonstrate which performs better on your workload.[6][7] Treat the initial ordering as an evaluation sequence and measure your target task locally.

Sources

1. microsoft/mdeberta-v3-base model card (Hugging Face) — 2026-09-25
2. DeBERTa: Decoding-enhanced BERT with Disentangled Attention — 2020-06-05
3. microsoft/deberta-v3-base model card (Hugging Face) — 2026-09-25
4. facebook/esm2_t33_650M_UR50D model card (Hugging Face) — 2026-09-25
5. facebook/esm2_t6_8M_UR50D model card (Hugging Face) — 2026-09-25
6. LiquidAI/LFM2.5-Encoder-350M model card (Hugging Face) — 2026-09-25
7. LiquidAI/LFM2.5-Encoder-230M model card (Hugging Face) — 2026-09-25
8. google-bert/bert-base-uncased model card (Hugging Face) — 2026-09-25
9. BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding — 2018-10-11
10. FacebookAI/xlm-roberta-base model card (Hugging Face) — 2026-09-25
11. Unsupervised Cross-lingual Representation Learning at Scale — 2019-11-05
12. distilbert/distilbert-base-uncased model card (Hugging Face) — 2026-09-25
13. DistilBERT, a distilled version of BERT: smaller, faster, cheaper and lighter — 2019-10-02
14. FacebookAI/roberta-base model card (Hugging Face) — 2026-09-25
15. RoBERTa: A Robustly Optimized BERT Pretraining Approach — 2019-07-26