Open Source
Open Source

Sequence In, Structure Out: Why Did a 62-Star Repo Make Nature?

structRFM is a structure-guided RNA foundation model from the MIRACLE lab at USTC; the paper appeared in Nature on November 5, 2026 (DOI 10.1038/s41586-026-11210-2). The repository heqin-zhu/structRFM is MIT licensed and showed 62 stars in a November 6, 2026 GitHub API check; it was created in February 2025 and its README still points to the August 2025 bioRxiv preprint. The team says the roughly 21 million sequence-structure pairs, model weights and source code are public: the dataset is built from RNAcentral and BPfold with a 512-token length cap and is 4.5 GB on Zenodo. SgMLM structure-guided masked language modeling and MUSES multi-source structure ensembling let the model emit sequence-level, nucleotide-level and pair-level features from sequence alone, supporting secondary and tertiary structure prediction, splice site prediction, IRES identification, ncRNA classification and zero-shot homology classification.

Published November 6, 20269 min read
<!-- structrfm-rna-foundation-model-opensource-resource | open-source | Sequence In, Structure Out: Why Did a 62-Star Repo Make Nature? -->

Let us set the division of labor first. The piece on this site dated November 2, 2026 about Hydrogen-1.0 covers a 753B-parameter general-purpose science model for chemistry, materials and the life sciences. This article is about an RNA-sequence-specific foundation model that takes nothing but RNA sequence and is built to read RNA structure. The same batch also covers the event, a setup SOP and a comparison review; none of those angles is repeated here. The job of this article is to lay out what heqin-zhu/structRFM has actually opened, how to start, and which claims remain the team's own account.

The plain-text address is https://github.com/heqin-zhu/structRFM. It carries the MIT license, and Python is its primary language. As of November 6, 2026, a GitHub API snapshot showed 62 stars, 6 forks and 0 open issues; it was created on February 24, 2025, with a last push on August 29, 2026. What brought it wider attention was a paper in Nature on November 5, 2026, DOI 10.1038/s41586-026-11210-2. Draw one time boundary first: this is not a repository that appeared in November. It predates the paper by over a year, and the README top still points to a bioRxiv preprint of August 6, 2025. Per Science and Technology Daily and the USTC news office, the team states that the paired data, model weights and source code are open. The correct reading: the paper reached a top journal on November 5 while the repository and data were already open, so the two events should not be treated as one.

So the contrast: a 62-star repository whose README still points to the preprint has laid out 21 million structure pairs, pre-trained weights, fine-tuned checkpoints and a feature toolkit.

A Nature paper and a repository that predates it by over a year

According to Science and Technology Daily and the USTC news office, the work comes from the MIRACLE lab at USTC, led by Professor Shaohua Zhou and Professor Peng Xiong, with Dr. Heqin Zhu as first author, published in Nature on November 5, 2026 under DOI 10.1038/s41586-026-11210-2. The team states that the paired data, model weights and source code are open to the research community.

The repository is older. GitHub metadata shows heqin-zhu/structRFM created on February 24, 2025. The README links to the August 6, 2025 bioRxiv preprint 2025.08.06.668731, and its citation entry remains a preprint citation for "A fully-open structure-guided RNA foundation model for robust structural and functional inference", DOI 10.1101/2025.08.06.668731. The last push is August 29, 2026: repository in February 2025, preprint in August 2025, code updates through August 2026, journal publication in November 2026.

That boundary matters because the journal publication and the repository opening are easily treated as one event, and the material does not support that. Framing it as a sudden surge of attention would contradict the November 6, 2026 GitHub API numbers of 62 stars. Interesting, rather, is the gap between journal publication and resources open long before.

Sequence in, structure out: how it works

The core claim: at inference, given nothing but RNA sequence, the model yields features at three levels, sequence-level, nucleotide-level and nucleotide-pair-level, without a known secondary structure supplied up front. Structure labels are expensive, usually from experiment or computational prediction, and the model folds that step into pre-training.

Two designs carry this. SgMLM, Structure-guided Masked Language Modeling, dynamically balances sequence-level and structure-level masking to capture base-pair interactions without task-specific bias, per the README. SgMLM consults structural information when masking, forcing the model to learn which positions tend to pair, the most fundamental constraint of RNA secondary structure.

MUSES, Multi-source ensemble of secondary structures, integrates three predictor families: thermodynamics-based, probability-based and deep-learning-based. RNA secondary structure labels are not clean; each predictor has systematic error, so trusting one would teach that bias verbatim. An ensemble cross-checks the labels and mitigates single-source annotation bias.

Pre-training uses 21 million sequence-secondary-structure pairs constructed from RNAcentral and BPfold, filtered to length 512. The README says this data with SgMLM and MUSES reaches what it calls state-of-the-art performance across RNA structural and functional inference tasks. One qualifier is essential: that "state-of-the-art" phrasing is the team's and README's own account, not a conclusion from independent third-party reproduction.

Outputs map to cls_feat, seq_feat and mat_feat: one vector for the sequence, one per nucleotide, one matrix over pairs.

What is actually open: data, weights, and the MIT license

"All given away" only counts if it can be downloaded. By the README and root, the open list has four parts: the pre-training paired dataset, pre-trained weights, per-task fine-tuned checkpoints and source code.

The dataset is on Zenodo, DOI 10.5281/zenodo.16754363, with pre-training pairs of about 4.5 GB. The README notes the Hugging Face dataset heqin-zhu/structRFM-dataset is under construction, so Zenodo is the safe path rather than expecting one load_dataset call. Fine-tuning needs a further 3.7 GB of task data and checkpoints in the corresponding task folders. The pre-trained weights are an approximately 300 MB structRFM_checkpoint.tar.gz from GitHub releases, unpacked and pointed to through the structRFM_checkpoint environment variable.

The root holds README.md, LICENSE, demo.py, main.py, pyproject.toml and structRFM_environment.yaml plus src, tasks, scripts and images; a structRFM package is on PyPI. README badges list Python 3.8 or newer and PyTorch 2.0.1. No GPU or VRAM requirement is given, and the brief forbids inventing unpublished numbers, so only dependency versions are listed here.

The license is MIT, LICENSE 1066 bytes, Copyright (c) 2025 Heqin Zhu. The LICENSE original permits use, copying, modification, merging, publication, distribution, sublicensing and sale, with the sole condition of retaining the copyright and permission notices, and provides the software "AS IS" without warranty. This is a restatement, not legal advice; read the LICENSE original before commercial use. MIT on the weights does not mean training data, fine-tuning data and the full recipe share one entry point; data, weights and code are spread across GitHub releases, Zenodo, PyPI and Hugging Face.

Two ways in: from AutoModel to structRFM_infer

The README offers a light path and a heavier one.

The light path needs only transformers: load with AutoModel and AutoTokenizer from heqin-zhu/structRFM, and one sequence gives hidden states. The single-sequence example GUCCCAACUCUUGCGGGGAGGGAU is 24 bases, producing last_hidden_state [1, 24, 768] and pooler_output [1, 768]; batch mode with max_length=512 and padding to maximum length gives [3, 512, 768] for three sequences. That 768 is the hidden dimension.

text
from transformers import AutoModel, AutoTokenizer

model = AutoModel.from_pretrained('heqin-zhu/structRFM')
tokenizer = AutoTokenizer.from_pretrained('heqin-zhu/structRFM')

seq = 'GUCCCAACUCUUGCGGGGAGGGAU'
outputs = model(**tokenizer(seq, return_tensors='pt'))
print(outputs.last_hidden_state.shape)

The heavier path uses the structRFM wrapper. Install with pip install transformers structRFM BPfold, unpack the roughly 300 MB checkpoint, set the environment variable, then build with structRFM_infer. README parameters are max_length=514, dim=768, layer=12, num_attention_heads=12: 12 layers, 12 attention heads, hidden size 768. extract_feature returns cls_feat [768] for the whole-sequence feature, seq_feat [L, 768] per nucleotide and mat_feat [L, L] for the pair matrix. With AGUACGUAGUA of length 11, seq_feat is [11, 768] and mat_feat [11, 11].

text
import os
from structRFM.infer import structRFM_infer

model = structRFM_infer(
    from_pretrained=os.getenv('structRFM_checkpoint'),
    max_length=514, dim=768, layer=12, num_attention_heads=12,
)
feat = model.extract_feature('AGUACGUAGUA')

You can also build with get_structRFM(dim=768, layer=12, num_attention_heads=12, ..., max_length=514) and get_mlm_tokenizer(max_length=514). Two numbers are easy to confuse: 512 is the dataset length cap, 514 the model max_length, with two positions reserved for special tokens. The README describes an overlapping sliding-window strategy extending long non-coding RNA classification to roughly 3,000 nucleotides, a compromise around 512 rather than native arbitrary-length support. For fine-tuning, compare the general LLM fine-tuning SOP; the tasks directory here is where this model lands.

What it can do, and what is still self-reported

tasks sorts the capabilities: tasks/zeroshot for zero-shot inference, tasks/seqcls_ssp for secondary-structure prediction and ncRNA classification, tasks/Zfold for tertiary-structure prediction, tasks/splice_site_prediction for splice site prediction. Secondary-structure prediction can also use structRFM_SSP_bpRNA1m.pt or structRFM_SSP_RNAStrAlign.pt.

By the README and official news account, functional inference covers splice site prediction, IRES (internal ribosome entry site) identification and non-coding RNA classification; the structural side improves secondary-structure prediction, and feeding features into a tertiary-structure predictor improves both 3D structure and the corresponding secondary structure. It keeps secondary-structure performance on newly released RNA families, and segmentation brings long non-coding RNA classification into scope. Zero-shot homology classification ranks top 4 on Rfam and ArchiveII, and ablations validate structural information and the masking strategy. The official wording is that it is expected to help drug discovery and the understanding of biological mechanisms: only "expected to help", with no claim that any therapy is approved or any drug is in use.

That results list is the team's and README's own account, marked in the brief as lacking independent third-party reproduction. Use it as a filter for which tasks to try first, not as externally validated conclusions, and do not align across leaderboards.

Limits and boundaries

First, length: the dataset was filtered to 512, model max_length is 514, and long sequences use overlapping sliding windows, not native arbitrary-length support. Second, entry points are scattered: 4.5 GB on Zenodo, a further 3.7 GB of fine-tuning data and checkpoints, and roughly 300 MB of pre-trained weights, with heqin-zhu/structRFM-dataset still under construction. Third, the community is small: 62 stars, 6 forks, 0 open issues, so environment and version problems are usually solved by reading source and README yourself. Fourth, the README contains a few spelling errors, for example around the words achieves and pretraining; read them with the correct spelling and do not copy them. Fifth, keep self-reported claims and third-party reproduction apart.

Sixth, the easiest line to cross: only the README dependency versions are listed here, with no GPU, VRAM or training-time figures, because the material has none and the brief forbids inventing them. Applications keep only the original "expected to help drug discovery and the understanding of biological mechanisms" phrasing, without clinical or deployment claims. One more practical note: the pre-trained checkpoint and the fine-tuned checkpoints are separate downloads, so a complete local setup touches GitHub releases, Zenodo and PyPI rather than a single repository clone.

FAQ

Q1: Is the journal publication date the date the repository opened? A1: No. heqin-zhu/structRFM was created on February 24, 2025, last pushed August 29, 2026, and its README still points to the August 6, 2025 bioRxiv preprint. November 5, 2026 is when the paper appeared in Nature (DOI 10.1038/s41586-026-11210-2), with the team stating data, weights and source code are open. A November 6, 2026 GitHub API snapshot showed 62 stars, consistent with a repository and preprint that both predate the paper.

Q2: Does MIT mean unrestricted commercial use? A2: MIT is among the most permissive licenses. The original allows use, copying, modification, merging, publication, distribution, sublicensing and sale, with the sole condition of retaining copyright and permission notices, and provides the software "AS IS". This is a restatement, not legal advice; read the original before commercial use, and note data is not bundled with the weights.

Q3: Can it read structure from sequence alone, and what are the length limits? A3: By the README, SgMLM and MUSES are pre-trained on 21 million pairs from RNAcentral and BPfold, and sequence-only inference yields cls_feat [768], seq_feat [L, 768] and mat_feat [L, L]. The dataset is filtered to 512, model max_length is 514, and long sequences use overlapping sliding windows; the README says this extends long non-coding RNA classification to roughly 3,000 nucleotides.

Q4: Can the zero-shot top-4 and state-of-the-art claims be treated as conclusions? A4: Read them with a discount. They are the team's and README's own account, marked as lacking independent third-party reproduction, covering the zero-shot homology top-4 on Rfam and ArchiveII plus structural improvements and ablation results. Treat them as a filter for which tasks to try first and test on your own data.

Q5: What do I install, and how large is the data? A5: The light path needs only pip install transformers with AutoModel and AutoTokenizer, the 24-base example giving [1, 24, 768]. The full path needs pip install transformers structRFM BPfold, an approximately 300 MB checkpoint and its environment variable, then structRFM_infer(max_length=514, dim=768, layer=12, num_attention_heads=12). The Zenodo pre-training set is 4.5 GB (DOI 10.5281/zenodo.16754363), with a further 3.7 GB of fine-tuning data. Dependencies: Python 3.8 or newer, PyTorch 2.0.1.

Related reading

This article is AI-assisted and human-edited. Last updated: 2026-11-06

FAQ

Is the journal publication date the date the repository opened?
No. heqin-zhu/structRFM was created on February 24, 2025, last pushed August 29, 2026, and its README still points to the August 6, 2025 bioRxiv preprint. November 5, 2026 is when the paper appeared in Nature (DOI 10.1038/s41586-026-11210-2), with the team stating data, weights and source code are open. A November 6, 2026 GitHub API snapshot showed 62 stars, consistent with a repository and preprint that both predate the paper.
Does MIT mean unrestricted commercial use?
MIT is among the most permissive licenses. The original allows use, copying, modification, merging, publication, distribution, sublicensing and sale, with the sole condition of retaining copyright and permission notices, and provides the software "AS IS". This is a restatement, not legal advice; read the original before commercial use, and note data is not bundled with the weights.
Can it read structure from sequence alone, and what are the length limits?
By the README, SgMLM and MUSES are pre-trained on 21 million pairs from RNAcentral and BPfold, and sequence-only inference yields cls_feat [768], seq_feat [L, 768] and mat_feat [L, L]. The dataset is filtered to 512, model max_length is 514, and long sequences use overlapping sliding windows; the README says this extends long non-coding RNA classification to roughly 3,000 nucleotides.
Can the zero-shot top-4 and state-of-the-art claims be treated as conclusions?
Read them with a discount. They are the team's and README's own account, marked as lacking independent third-party reproduction, covering the zero-shot homology top-4 on Rfam and ArchiveII plus structural improvements and ablation results. Treat them as a filter for which tasks to try first and test on your own data.
What do I install, and how large is the data?
The light path needs only pip install transformers with AutoModel and AutoTokenizer, the 24-base example giving [1, 24, 768]. The full path needs pip install transformers structRFM BPfold, an approximately 300 MB checkpoint and its environment variable, then structRFM_infer(max_length=514, dim=768, layer=12, num_attention_heads=12). The Zenodo pre-training set is 4.5 GB (DOI 10.5281/zenodo.16754363), with a further 3.7 GB of fine-tuning data. Dependencies: Python 3.8 or newer, PyTorch 2.0.1.

Related

Open Source

Even Failed Experiments Trained It: An MIT Science LLM

On November 2, Deep Principle released and open-sourced Hydrogen-1.0: a 753B science LLM post-trained from GLM-5.3, under MIT, live on ModelScope and HuggingFace (deep-principle/Hydrogen-1.0, about 1.51TB BF16, plus NVFP4/MXFP4 variants, tested on 8 GPUs with SGLang). Vendor-reported FSR 38.3% beats GPT-6-Astra at 33.3% and GPQA-Diamonds 93.0% nears Kimi-K3; its signature is training on its own lab records including failed experiments, with a Lab Compile step that catches faulty experiment instructions.

Nov 4, 20269 min read
Open Source

Open-source Dots: 2,400 stars in three days

A teardown of feder-cr/dots (GitHub API snapshot 2026-10-02): 2,416 stars, 421 forks, MIT-licensed Python, created 2026-09-29 - an open-source isotope that hit escape velocity the day after OpenAI's closed Dots debut. Its core thesis: the model is swappable with one flag, the browser is what the website actually sees. A real Firefox engine patched in C++ decides the fingerprint inside the engine rather than as a page-inspectable JavaScript coat; one seed equals one consistent identity (screen, fonts, GPU, timezone and language agree, reproducibly); nothing for a page to find (no WebDriver flag, no DevTools protocol, no automation globals); the pointer travels before it clicks and keys are pressed one at a time so events arrive trusted; --profile-dir keeps logins across runs; with --proxy the timezone and language follow the exit. Models come from OpenRouter with a one-flag swap, and the companion repo invisible_playwright_mcp exposes the same browser as an MCP server for Claude Code, Codex and Gemini CLI. The README states plainly it is not affiliated with OpenAI. Includes a compliance boundary note: respect target-site terms and local law; no fraud, ticket-scalping or bulk sign-ups.

Oct 2, 20269 min read
Open Source

DeepSeek Harness: A Plugin-Everything Agent Framework

DeepSeek open-sourced its agent orchestration framework DeepSeek Harness (CLI: dsh) on GitHub under MIT, written in TypeScript and built on the Cordis runtime with an "everything-is-a-plugin" architecture that modularly assembles AI pipelines. The repo was created 2026-08-13 and passed 200k stars within ~3 weeks; it is currently 0.1.3-alpha, a developer preview with breaking changes expected (read SAFETY.md first). Launch the Web UI with `npx @deepseek-ai/dsh web` at http://127.0.0.1:3080.

Sep 5, 202610 min read