LucaOne: a unified nucleotide and protein language model from Alibaba Cloud's LucaGroup

The problem LucaOne is aimed at: one model for DNA, RNA and protein

Most sequence models in computational biology pick a modality. Protein language models read amino acids. Nucleotide models read DNA or RNA. If your pipeline crosses that boundary, for example a task that starts from a gene and ends at a protein property, you either chain two models and accept the interface loss, or you train something joint yourself. LucaOne is LucaGroup's attempt at the joint option. The README describes it as a "Generalized Biological Foundation Model with Unified Nucleic Acid and Protein Language", and the accompanying paper is published in Nature Machine Intelligence (2025). The repository ships the model code, training scripts, embedding inference code and trained checkpoints, which means the intended user is not a bench biologist clicking a web demo. It is someone who can run Python, manage a GPU, and read a config table. The topics list confirms the framing: ai4biology, sequence-based-embedding, nucleic-acid-and-protein-language.

How the unified architecture is packaged: three model families, one codebase

The repository keeps a single architecture and varies the training data behind it. The README's embedding recommendation table is the clearest statement of this. Three checkpoint families are listed: lucaone/lucaone at steps 36000000, 17600000 or 5600000, trained on both gene (DNA, RNA) and protein sequences; lucaone/lucaone-gene at step 36800000, trained only on DNA and RNA; and lucaone/lucaone-prot at step 30000000, trained only on protein. The selection is driven by three parameters, --llm_type, --llm_version and --llm_step, and the README states the project will download the matching checkpoint from FTP automatically based on those values. That is the whole distribution mechanism. There is no model registry entry, no manifest file described in the material, and no checksum mentioned. On the Hugging Face branch the picture is different: the timeline entry for 2025/12/31 lists LucaGPLMModel for sequence embedding, LucaGPLMForMaskedLM for pre-training and sequence recovery, LucaGPLMForSequenceClassification for sequence-level tasks such as protein family, solubility or promoter prediction, and LucaGPLMForTokenClassification for residue-level tasks such as secondary structure, binding sites or post-translational modifications. Those names map onto the standard transformers task-head convention, which is a meaningful design choice: it means downstream users write the same training loop they would write for any other encoder.

Getting embeddings out: the --llm_type, --llm_version, --llm_step triple

The embedding path is the part of the repository with the most concrete instructions. The README points at src/get_embedding.py, noting it was optimized on 2024/10/01, and the checkpoint selection table gives the exact argument values. For a mixed workload you would pass --llm_type lucaone --llm_version lucaone --llm_step 36000000. For nucleotide-only work, --llm_version lucaone-gene with --llm_step 36800000. For protein-only work, --llm_version lucaone-prot with --llm_step 30000000. The README explicitly warns that the gene and protein variants are for their own sequence types only, so feeding protein sequences to lucaone-gene is a misuse the tool does not appear to guard against. On the infrastructure side, the installation section is a problem. It documents git installation for CentOS and Ubuntu, then Python 3.9 via Anaconda, but the README as supplied cuts off mid-command at "wget ht". You cannot reconstruct the full environment setup from this document alone. The 2025/12/26 timeline entry adds a --use_bf16 flag for training and embedding inference, with the parenthetical "Not recommended for use". That is an unusual piece of documentation: a flag is shipped and simultaneously discouraged, with no stated reason.

Fine-tuning through the Hugging Face branch rather than the main tree

The 2025/12/31 entry says LucaOne now supports the Hugging Face interface for further training, and directs readers either to the LucaGroup collection on Hugging Face or to the huggingface branch of the repository. The stated support covers AutoModel, AutoModelForMaskedLM, AutoModelForSequenceClassification, AutoModelForTokenClassification, AutoConfig and AutoTokenizer. Two training modes are described: sequence-only inputs, or injecting biological knowledge following the LucaOne framework. This matters because it changes the cost of adoption. If you are already inside the transformers ecosystem, the branch lets you fine-tune for sequence-level or token-level classification and regression without learning a bespoke training harness. The main branch, by contrast, is where the original training scripts live. The split is a real friction point: the two branches are not described as feature-equivalent, and the README does not state whether the Hugging Face checkpoints and the FTP checkpoints are the same weights. If reproducibility matters to your work, that question needs an answer before you build on either.

Where LucaOne is the wrong tool

The dependency on a bare IP address for checkpoints is the sharpest limitation. The README links model files at http://47.93.21.181/lucaone/TrainedCheckPoint/..., which is an unencrypted HTTP endpoint with no domain name. For a long-lived research pipeline this is fragile: IP addresses change, and there is no described mirror or integrity check. The Hugging Face collection at huggingface.co/LucaGroup is the more durable route, and the README treats it as a separate delivery channel rather than the default. A second limitation is scope. LucaOne is a sequence model. If your problem is structure prediction, single-cell expression, or anything whose signal is not in the primary sequence, the unified nucleotide and protein language is not addressing it, and the repository offers no indication otherwise. Third, the documentation is a changelog with a paper attached. Installation is incomplete in the supplied README, the pre-training dataset is deposited externally (CNGB Sequence Archive, accession CNP0007266) rather than bundled, and there is no retrieved release history to pin a version against. Anyone who needs a frozen artifact and a support contract should look elsewhere.

The alternative to weigh: modality-specific models versus one joint encoder

The obvious comparison is against established single-modality models such as ESM-style protein language models or nucleotide-specific encoders. The difference is architectural, not just quantitative. A protein-only model treats the amino acid alphabet as the entire vocabulary and never sees a codon. LucaOne's premise, per the README and the Nature Machine Intelligence paper title, is that nucleotide and protein sequences should share one representation, which the repository illustrates with a Central Dogma figure showing few-shot learning of the DNA-to-RNA-to-protein relationship. If your task genuinely spans that boundary, a single-modality model cannot express it without an external alignment step. If your task does not span it, the joint model buys you nothing and costs you a larger, more awkward download. The README's own recommendation table concedes this by offering lucaone-gene and lucaone-prot as separate checkpoints, which is effectively an admission that specialised training on one modality is still worth having. Also relevant: LucaGroup's LucaProt work on RNA virosphere documentation and LucaVirus are separate projects in the same family, so if your interest is viral discovery specifically, check whether one of those fits before reaching for the general model.

Maintenance, licensing and what to check before you commit

The repository is Apache-2.0 and not archived, with a last push of 2026-05-25, so it is being maintained rather than parked. The activity pattern visible in the README is incremental: embedding inference optimisation in October 2024, a continue-training-on-failure feature in July 2024, new checkpoints in April 2025, the CNSA dataset deposit in June 2025, BF16 support in December 2025, and the Hugging Face interface at the end of December 2025. That is roughly a release cadence of one meaningful change every few months. The upgrade cost is mostly in checkpoint selection: because --llm_step is an explicit argument, moving to a newer checkpoint is a config change rather than a silent update, which is good for reproducibility. The licence permits commercial use and modification, but note that the README also advertises a patent portfolio (15 applications filed, 10 granted, 1 PCT pending) without stating whether any patent reads on the model weights or inference code. That is a question for your own counsel, not something this review can resolve. The concrete first step is to run the embedding path end to end with the documented triple, confirm the checkpoint downloads from whichever host your network allows, and check that the sequence types in your data match the llm_version you picked.

Editorial conclusion

Adopt LucaOne if you need one embedding space that covers both nucleotide and protein sequences, or if you want to fine-tune through the standard transformers API on the huggingface branch. Do not adopt it if you need a stable, versioned artifact host or a documented CLI: the README points checkpoints at a bare IP address (47.93.21.181) and its installation section is truncated mid-command. Before committing, verify that --llm_type lucaone --llm_version lucaone --llm_step 36000000 downloads successfully in your network, and confirm which sequence types your task actually needs, because the gene-only and protein-only checkpoints are not interchangeable with the full model.

Official sources

1. Issues
2. License: Apache-2.0
3. LucaOne/LucaOne on GitHub
4. Project website
5. README