Best Masked Language Models for CPU-Only PCs in 2026: LFM2.5-Encoder-350M and LFM2.5-Encoder-230M

Quick Answer

As of September 2026, LiquidAI’s LFM2.5-Encoder-350M is the top pick under “newest release first, then downloads,” sharing the newest release date and winning the download tiebreak [6][7]. 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), mDeBERTa-v3-base (Microsoft), and DeBERTa-v3-base (Microsoft) [6][7].

Key Takeaways

• LiquidAI’s LFM2.5-Encoder-350M ranks first because it shares the newest release date with LiquidAI’s LFM2.5-Encoder-230M and wins the downloads tiebreak.[6][7] Its 354M parameters imply 177 MB of 4-bit weights, estimated (params x 0.5 bytes), excluding runtime memory.[6]
• LiquidAI’s LFM2.5-Encoder-230M has 230M parameters: 115 MB of 4-bit weights, estimated (params x 0.5 bytes).[7] Both LiquidAI encoders list 128K-token context and the lfm1.0 license.[6][7]
• facebook’s esm2_t33_650M_UR50D and esm2_t6_8M_UR50D follow in that order.[4][5] Their respective 652M and 8M parameters imply 326 MB and 4 MB of 4-bit weights, estimated (params x 0.5 bytes).[4][5] Both list 1,026-token context and MIT licensing.[4][5]
• Microsoft’s mDeBERTa-v3-base and DeBERTa-v3-base complete the ranking, in that order; both list 512-token context and MIT licensing.[1][3] Parameter counts are unspecified, so weight-memory estimates are omitted.[1][3]
• Every candidate has no public benchmark yet for this comparison; the ordering does not establish CPU performance superiority.[1][3][4][5][6][7] Estimated weight storage should not be read as total RAM requirements.
• Ranking note: newest release first, then downloads.[1][3][4][5][6][7] The ranking admits only fill-mask models from labs with a published paper or leaderboard record. Too few releases meet the last-12-month gate, so the newest available are included.[1][3][4][5][6][7] Established picks—the three most-downloaded candidates, Microsoft’s two models and facebook’s esm2_t33_650M_UR50D—bypass that gate, follow the same ordering rule, and cannot take first through exemption.[1][3][4]

How do masked language models compare on weight memory, context, licenses and published benchmarks?

Which masked language models should you consider for a CPU-only PC?

1. LFM2.5-Encoder-350M

LFM2.5-Encoder-350M by LiquidAI ranks first because it shares the newest listed release date, July 27, 2026, with LiquidAI’s LFM2.5-Encoder-230M and wins the download tiebreak: 29,446 versus 7,111 downloads.[6][7] The ordering is newest release first, then downloads; no public benchmark scores any candidate. The ranking admits only fill-mask models from labs with a published paper or leaderboard record. The family has too few recent releases, so the newest available models are included alongside older entries.

LiquidAI lists 354M parameters, a context length of 128K tokens, F32 weights of 1.4 GB, and the lfm1.0 license.[6] Quantized weight storage would be approximately 177 MB at 4-bit—estimated (params x 0.5 bytes), using the cited 354M parameters.[6] For a CPU-only PC, treat that estimate as a weight-storage budget, not a total RAM requirement. Actual hardware planning still needs a compatible runtime and an allowance for memory beyond the weights; the estimate alone cannot establish whether a particular PC will run the model.

Consider the model for local fill-mask experiments where its listed 128K-token context is relevant.[6] Start with the input lengths your application actually needs before attempting the full context. The caveat is performance validation: no public benchmark yet. Its position reflects release timing and the download tiebreak, so the ranking does not establish CPU speed or prediction quality against the other candidates.

2. LFM2.5-Encoder-230M

LFM2.5-Encoder-230M by LiquidAI ranks second under the ordering rule: newest release first, then downloads.[7][6] Both LiquidAI candidates were published on July 27, 2026; its 7,111 downloads trail the larger sibling’s 29,446 over the reporting window.[7][6] The benchmark status is “no public benchmark yet,” so the position reflects publication timing and a popularity tiebreak, not demonstrated CPU performance. Downloads do not establish inference speed or model quality.

The model has 230M parameters, a declared context length of 128K tokens, and an lfm1.0 license.[7] Published F32 weights occupy 0.9 GB.[7] For quantized weight storage, the budget is approximately 115 MB at 4-bit, estimated (params x 0.5 bytes) from the cited 230M parameters.[7] Treat that calculation as a planning baseline when evaluating a local CPU deployment; total RAM requirements and a supported CPU configuration are not established here.

Consider the model for a local fill-mask workflow where its declared context capacity is relevant and you can validate the runtime on your own machine. The practical caveat is that calculated weight storage does not demonstrate an available quantized implementation or acceptable latency. Check CPU backend support, license terms, and memory use at your intended input length before committing to deployment.

3. esm2_t33_650M_UR50D

esm2_t33_650M_UR50D from facebook ranks third under the ordering rule “newest release first, then downloads,” following the newer LiquidAI encoder releases. [4][6][7] An established pick, it qualifies for the recency exemption through its download count: 2,063,734 downloads in the reporting window ending September 25, 2026. [4] Its first publication on Hugging Face was September 27, 2022, so its position should not be read as evidence of a recent release or superior benchmark performance. [4]

The model has 652M parameters, a context length of 1,026 tokens, and an MIT license. [4] Published F32 weights occupy 2.6 GB. [4] For CPU-only memory planning, the 652M parameter count gives approximately 326 MB of 4-bit weights, estimated (params x 0.5 bytes). [4] A local PC needs RAM beyond the weights for execution; that estimate is not a total system RAM requirement or confirmation that a compatible quantized runtime is available.

Choose it for local fill-mask experiments whose inputs fit the documented 1,026-token context and whose deployment requirements favor the MIT license. [4] The performance caveat is straightforward: no public benchmark yet. CPU speed and practical memory use therefore remain unverified here; validate both in your intended runtime before committing to deployment.

4. esm2_t6_8M_UR50D

esm2_t6_8M_UR50D from facebook ranks fourth under the ordering rule “newest release first, then downloads.”[4][5][1][3][6][7] Its Hugging Face publication date, September 26, 2022, places it behind facebook’s esm2_t33_650M_UR50D and ahead of the Microsoft entries.[4][5][1][3] The family has too few recent releases, so the ranking includes the newest available candidates. Eligibility is limited to fill-mask models from labs with a published paper or leaderboard record. The benchmark status is “no public benchmark yet.”

The model has 8M parameters, a context length of 1,026 tokens and an MIT license.[5] Weight memory at 4-bit precision would be approximately 4 MB, estimated (params x 0.5 bytes) from the cited 8M parameters.[5] Treat that figure as a weight-storage estimate when planning a local installation. Quantization support, runtime compatibility and total system memory requirements still need verification before deployment on a CPU-only PC.

Consider this model for local fill-mask experiments where a small parameter count is a selection priority.[5] Start by checking whether your intended CPU runtime supports the model and your chosen weight format. The practical caveat is that the weight estimate does not establish execution speed, task quality or a complete RAM requirement. Its position in this list reflects release ordering; no public benchmark yet establishes a performance advantage over the other candidates.

5. mDeBERTa-v3-base

mDeBERTa-v3-base by Microsoft ranks fifth under the ordering rule “newest release first, then downloads,” with no public benchmark yet.[1] Its Hugging Face publication date matches Microsoft’s DeBERTa-v3-base at March 2, 2022, but its 5,455,850 downloads exceed that model’s 2,797,571 over the same reporting window.[1][3] Those downloads settle the tie; they do not establish better accuracy or CPU performance. mDeBERTa-v3-base is an established pick, among the three highest-download candidates, rather than a recent release.[1][3][4][5][6][7]

Microsoft specifies a context length of 512 tokens and an MIT license.[1] Consider it for local fill-mask evaluation when your inputs fit that context limit and your project calls for MIT-licensed weights.[1] The ranking admits only fill-mask models from labs with a published paper or leaderboard record. Microsoft’s accompanying DeBERTa paper documents the family’s disentangled-attention approach, providing background for engineers evaluating the architecture.[2]

Hardware sizing remains the practical caveat. A defensible CPU specification or minimum RAM requirement cannot be given without verified memory and runtime measurements. Quantized weight memory also cannot be estimated responsibly without a cited parameter count. Treat local CPU suitability as something to validate with your intended runtime and workload before committing to deployment; download popularity does not answer that question.

6. DeBERTa-v3-base

DeBERTa-v3-base by Microsoft ranks sixth as an established pick retained beyond the recency gate.[3] The ordering is newest release first, then downloads; no public benchmark scores any candidate. Its status is no public benchmark yet. The checkpoint shares its publication date of March 2, 2022, with Microsoft’s mDeBERTa-v3-base, but trails that model on monthly downloads: 2,797,571 versus 5,455,850.[1][3] Older checkpoints remain eligible because the family has too few recent releases.

The model supports a context length of 512 tokens and carries the MIT license.[3] Consider it for local fill-mask experiments on short inputs, particularly when that license suits your project. Keep the context ceiling in mind when preparing inputs: longer documents require a deliberate strategy for selecting or splitting text. The associated paper is Microsoft’s “DeBERTa: Decoding-enhanced BERT with Disentangled Attention.”[2]

Hardware sizing is the caveat. Quantized weight memory, total RAM requirements and CPU throughput remain unverified, so a specific minimum PC configuration would be speculative. Before committing to a deployment, measure memory use and latency with your intended runtime and representative inputs. Treat this entry as a candidate to evaluate locally, with CPU suitability still to establish.

How do you estimate quantized weight memory from parameter counts?

Estimate quantized weight memory by multiplying the cited parameter count by the target storage per parameter: for 4-bit weights, use estimated (params x 0.5 bytes).[6][7] Treat the result as a weight-storage budget, not a measured download size or total application memory requirement.

LiquidAI’s LFM2.5-Encoder-350M (LiquidAI) has 354M parameters: 177 MB estimated (params x 0.5 bytes).[6] LiquidAI’s LFM2.5-Encoder-230M (LiquidAI) has 230M parameters: 115 MB estimated (params x 0.5 bytes).[7] Both calculations use decimal megabytes and the published parameter counts, rather than inferring a count from the model name.

The same calculation applies to facebook’s esm2_t33_650M_UR50D (facebook): its 652M parameters give 326 MB estimated (params x 0.5 bytes).[4] Facebook’s esm2_t6_8M_UR50D (facebook) has 8M parameters, giving 4 MB estimated (params x 0.5 bytes).[5] Keep the estimate label beside each result so readers can distinguish arithmetic from a measured quantized artifact.

For a CPU-only PC, use these estimates to compare potential weight storage. The calculation alone does not establish whether a compatible quantized release exists, how much RAM an application needs, or how quickly inference runs. A memory estimate therefore cannot justify a claim that a model fits a particular PC or performs well on its processor.

Which masked language models have an MIT license?

Microsoft’s mDeBERTa-v3-base (Microsoft) [1] and DeBERTa-v3-base (Microsoft) [3], plus Facebook’s esm2_t33_650M_UR50D (facebook) [4] and esm2_t6_8M_UR50D (facebook) [5], have an MIT license. Those are the MIT-licensed choices in this selection; license alone does not establish their relative performance on a CPU-only PC.

Both Microsoft models have a context length of 512 tokens.[1][3] Neither has a public benchmark yet in this comparison. Choose between them using your workload’s requirements, without treating their shared license or context limit as evidence of equivalent results.

Facebook’s esm2_t33_650M_UR50D (facebook) has 652M parameters and a context length of 1,026 tokens.[4] Its weight storage at 4-bit is approximately 326 MB, estimated (params x 0.5 bytes) from that parameter count.[4] Facebook’s esm2_t6_8M_UR50D (facebook) has 8M parameters and the same 1,026-token context limit; its 4-bit weight storage is approximately 4 MB, estimated (params x 0.5 bytes).[5] Neither has a public benchmark yet in this comparison. Treat those estimates as weight-storage calculations, not guarantees of total RAM requirements or CPU speed.

LiquidAI’s LFM2.5-Encoder-350M (LiquidAI) uses lfm1.0,[6] as does LiquidAI’s LFM2.5-Encoder-230M (LiquidAI).[7] For a deployment that specifically requires MIT licensing, keep the Microsoft and Facebook candidates on your shortlist and evaluate their suitability separately from licensing.

How are masked language models ranked when no public benchmark scores them?

Masked language models with no public benchmark scores are ranked newest release first, then downloads.[1][3][4][5][6][7] The ranking admits only fill-mask models from labs with a published paper or leaderboard record, using Hugging Face’s fill-mask pipeline tag.

The release window contains too few candidates, so the newest available releases are included alongside older established picks.[1][3][4][5][6][7] Microsoft’s mdeberta-v3-base and deberta-v3-base, plus facebook’s esm2_t33_650M_UR50D, are the established picks: the listed family’s most-downloaded models, which bypass the recency gate without earning the first position through that exemption.[1][3][4]

LiquidAI’s LFM2.5-Encoder-350M takes the first position because it shares the newest publication date with LiquidAI’s LFM2.5-Encoder-230M and has more downloads, making popularity a tiebreak rather than evidence of benchmark superiority.[6][7] The remaining order is LFM2.5-Encoder-230M, esm2_t33_650M_UR50D, facebook’s esm2_t6_8M_UR50D, mdeberta-v3-base, then deberta-v3-base.[7][4][5][1][3]

Every entry carries the label “no public benchmark yet.” A leaderboard can compare only models it actually scores, and an older scored model cannot displace a newer unscored release. Model-card benchmark results, when available, must be identified as self-reported.

CPU suitability remains a separate assessment of weight memory, context and license. For example, LFM2.5-Encoder-350M has 354M parameters: its 4-bit weight storage is approximately 177 MB, estimated (params x 0.5 bytes).[6] That weight-only estimate does not establish total RAM requirements or CPU speed. Its listed context is 128K tokens and its license is lfm1.0.[6] Model size does not determine the ordering.

Frequently Asked Questions

How are the masked language models ranked for CPU-only PCs?

Ranking note: only fill-mask models from labs with a published paper or leaderboard record qualify. No public benchmark scores any candidate, so the ordering is newest release first, then downloads. The ranking is LiquidAI’s LFM2.5-Encoder-350M (LiquidAI) [6], LiquidAI’s LFM2.5-Encoder-230M (LiquidAI) [7], Facebook’s esm2_t33_650M_UR50D (facebook) [4], Facebook’s esm2_t6_8M_UR50D (facebook) [5], Microsoft’s mDeBERTa-v3-base (Microsoft) [1], and Microsoft’s DeBERTa-v3-base (Microsoft) [3].

Why does LiquidAI/LFM2.5-Encoder-350M take first place?

LFM2.5-Encoder-350M (LiquidAI) takes first place because both LiquidAI candidates were published on July 27, 2026, and its 29,446 downloads exceed its sibling’s 7,111, making downloads the tiebreak after release date [6][7]. The placement does not establish superior accuracy or CPU speed: no public benchmark yet. Its listed parameter count is 354M, with a context limit of 128K tokens [6].

How much memory would quantized weights need?

For 4-bit weights, estimated (params x 0.5 bytes): LFM2.5-Encoder-350M (LiquidAI) has 354M parameters, giving 177 MB [6]; LFM2.5-Encoder-230M (LiquidAI) has 230M, giving 115 MB [7]; esm2_t33_650M_UR50D (facebook) has 652M, giving 326 MB [4]; esm2_t6_8M_UR50D (facebook) has 8M, giving 4 MB [5]. Those calculations cover weights alone. Actual CPU RAM requirements and compatible quantized execution remain unverified, so use the figures as planning estimates rather than measured deployment requirements.

Which context limits should I consider for local workloads?

Both LiquidAI encoders list a context limit of 128K tokens [6][7]. Both Facebook candidates list 1,026 tokens [4][5], while both Microsoft candidates list 512 tokens [1][3]. Choose a context limit that accommodates your intended input, but do not treat the listed limit as evidence of practical CPU performance. No published CPU timing or full-context RAM measurement establishes how these candidates behave at their limits.

What licenses do these models use?

The Microsoft candidates use MIT licenses [1][3], as do both Facebook candidates [4][5]. LFM2.5-Encoder-350M (LiquidAI) and LFM2.5-Encoder-230M (LiquidAI) use the lfm1.0 license [6][7]. License choice therefore deserves a separate check from context and weight memory. Review the applicable license text against your intended deployment before selecting a model; the license labels alone do not establish whether your particular use is permitted.

Why are older models included in a current ranking?

Recent releases are scarce in this family, so the newest available candidates are included [1][3][4][5][6][7]. Microsoft’s two candidates were published in March 2022 [1][3], and Facebook’s candidates in September 2022 [4][5]. The established picks are the three most-downloaded candidates: mDeBERTa-v3-base (Microsoft), DeBERTa-v3-base (Microsoft), and esm2_t33_650M_UR50D (facebook) [1][3][4][5][6][7]. Established picks bypass the recency gate, follow the same ordering rule, and cannot take first place through that exemption.

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