RiboFlare Core 0.9.0

RiboFlare Core is a high-throughput, ViennaRNA-compatible folding and RNA sequence-design core. It retains every earlier path: accelerated exact MFE and ensembles, both LinearFold-style beam engines, both bounded-span engines, and protein-to-mRNA design. Version 0.9.0 adds mixed coding/fixed/free constructs, regional and pairwise structure objectives, diverse top-k and Pareto output, and native Vienna sliding-window MFE, BPP, and accessibility analysis.

It is usable today for core folding, ensemble, structure-scoring, and mixed coding/non-coding sequence design work. It is not a drop-in replacement for every program shipped in the full ViennaRNA package.

Common workflows covered

Workflow	Support
Protein → synonymous mRNA	Joint folding-stability/CAI objective; standard genetic code; built-in human or custom codon usage; exact, beam, beam-fast, span, or span-shift oracle
Mixed RNA construct design	Ordered coding, immutable, and unconstrained-nucleotide segments; named subregions; invariant translation and fixed blocks
Regional structure design	Maximize/minimize paired bases in one region, or base pairs specifically crossing two selected regions
Multiple candidate design	Diverse top-k sequences and observed Pareto frontiers over Vienna energy, codon penalty, and structural-target penalty
Fast long-CDS design	Parallel sequence portfolio, exact sparse loop-factor refinement, paired-unit moves, and rank-adaptive fast/balanced/thorough budgets
Bulk exact MFE screening	Exact MFE energy and dot-bracket traceback; native optimization; ordered record-parallel batches
General long-RNA approximate MFE	Full or adaptive 5′→3′ beam search; tunable beam and loop budgets
Locality-constrained long-RNA MFE	Score-unpruned bounded-span DP; exact optimum under a chosen base-pair-width limit
Long-pair recovery from a narrow span	Optional cyclic-cut span portfolio with original-backbone Vienna rescoring
Ensemble characterization	Partition function, ensemble free energy, MFE probability, sparse base-pair probabilities, centroid, MEA, and ensemble diversity
Structure scoring	RNAeval-like energy evaluation, including &-separated strands
Constraint-guided folding	Hard dot-bracket constraints and Deigan SHAPE pseudoenergies
Local/window analysis	RNALfold-style local MFE hits, RNAplfold-style BPP, and unpaired-stretch accessibility through a native sliding recurrence
Boltzmann exploration	Reproducible stochastic backtracking with an explicit seed
Pipelines and services	FASTA, one-sequence-per-line, and JSONL input; text or ordered JSONL output; C++ API
Parameter sweeps	Temperature, salt, dangles, GU, lonely-pair, GU-closure, maximum-span, circular, and G-quadruplex controls

RNA sequence design

riboflare design accepts protein FASTA, one protein per line, or JSONL and returns a synonymous RNA coding sequence, a structure, folding energy, CAI, codon penalty, and the combined objective. For protein p, candidate sequence x, codon relative adaptiveness w(c), and CAI weight lambda, it minimizes

J(x) = E(x) - lambda * |p| * log(CAI(x))
     = E(x) + lambda * sum_c[-log w(c)].

This is the LinearDesign objective, but the implementation is not a port of the reference parser. The generalized JSONL/C++ interface concatenates three fixed-length segment types:

• coding: alternatives are synonymous codons for the supplied protein;
• fixed: the supplied RNA is copied exactly and never mutated;
• free: each base may use its declared alphabet and has no amino-acid or CAI constraint.

Named zero-based, half-open regions may select any subsection of a segment. A single-region objective maximizes or minimizes its number of paired bases. A two-region objective maximizes or minimizes base pairs crossing specifically between those disjoint ranges. Full coordinates, equations, validation rules, JSONL examples, and exactness boundaries are in DESIGN_SPEC.md.

RiboFlare alternates two operations:

1. A selectable RiboFlare oracle folds each synonymous candidate.
2. With that structure fixed, Vienna's structure energy is decomposed into sparse loop factors. Coordinate descent tests legal unit choices by updating only affected factors. Joint moves over units connected by a stem allow compensating base changes that one-unit descent cannot cross.

The fixed-structure step uses the active ViennaRNA 2.7.2 temperature, salt, dangle, GU, and special-hairpin parameters—not a GC or Nussinov surrogate. Its work is near-linear in CDS length for ordinary secondary structures. Candidates and refinement states run in parallel for a single protein; batches instead parallelize across proteins to avoid nested oversubscription.

With --engine exact, regional terms are part of Vienna's recurrence through algebraically equivalent soft energies. The reported mfe_kcal is the plain Vienna energy of the selected target-conditioned structure; objective also includes CAI and structural terms. Each fold/design alternation is monotone in that scalar objective. With an approximate oracle, structural terms are post-scored and target-guided seeds/refinement improve search, but the oracle does not prove the target-conditioned optimum. The parent design remains in the retained beam and an improved fixed structure is kept when the refold misses it, so the best-found objective is still monotone across rounds. In that rare scaffold_retained case, mfe_kcal is the Vienna energy of the retained valid structure (an upper bound on the true MFE), rather than a claim that the approximate oracle proved an optimum.

Three rank-adaptive search modes are available:

Mode	Initial portfolio	Retained beam	Rounds	Refinement
fast	3	2	2	one single-codon sweep; paired moves only on the leading half
balanced (default)	6	4	3	two single-codon sweeps; paired moves on the leading half
thorough	12	8	5	three single-unit and two paired-unit sweeps on every retained design

All budgets can be overridden. For tiny lattices, the modes automatically enumerate up to 128, 4,096, or 65,536 legal mixed sequences respectively before refinement. This makes small-lattice initialization exhaustive relative to the selected folding oracle without imposing that cost on long constructs.

The default folding oracle is beam-fast 100, which preserves long-range pairs and is the best general speed/quality default. span is the maximum- throughput option when a local-pair model is acceptable; exact gives the strongest thermodynamic guarantee. The five folding implementations themselves remain independently selectable through riboflare fold.

Human codon frequencies are built in. A custom positive-frequency table may contain CODON FREQUENCY or CODON AA FREQUENCY rows separated by commas, tabs, or spaces. Omitting a codon removes it from the design lattice; every amino acid present in the input must retain at least one codon.

--top-k N returns up to 64 distinct designs, optionally separated by --min-distance F normalized nucleotide Hamming distance. --pareto filters the output to the observed non-dominated frontier over (mfe_kcal, codon_penalty, interaction_penalty). Pareto status covers candidates evaluated in that run; it is not an exhaustive certificate for a large sequence lattice.

As with LinearDesign, lower thermodynamic MFE and higher CAI are computational proxies, not a guarantee of expression, half-life, immunogenicity, or clinical performance. Experimental validation and application-specific sequence safety checks remain necessary.

Five selectable MFE engines

Engine	Intended use	Search behavior
exact	Default; short/medium RNA, ensemble work, constraints, or exact Vienna compatibility	Accelerated exact RiboFlare/ViennaRNA 2.7.2 path
beam	Highest-fidelity long-RNA approximation	Full LinearFold-style beam recurrence; default beam 100 and loop cap 30
beam-fast	High long-RNA throughput with strong general accuracy	Rank-adaptive beam; eight leading states retain loop cap 30, others default to cap 6
span	Maximum speed when long base pairs may be excluded deliberately	No score pruning; exact MFE among structures with j - i < L
span-shift	Recover some long original-coordinate pairs while retaining narrow span searches	Several cyclic cuts, mapped-back validity checks, and Vienna rescoring

The exact build uses ViennaRNA 2.7.2 parameters and RNAlib semantics. Its specialized MFE kernel performs the same integer Turner-energy recurrence. Unsupported exact fast-path combinations automatically use the general RNAlib implementation; they never silently switch to approximation.

The specialized exact MFE path covers a single linear strand with dangles 0 or 2, no hard or SHAPE constraint, lonely pairs enabled, GU closures enabled, and no G-quadruplex or sampling request. Temperature, salt, --noGU, and --max-span remain supported. Eligible partition-function requests use the accelerated single-strand RNAlib recurrence. Other exact combinations use the general Vienna implementation automatically.

Bounded-span guarantee

For a sequence of length n, define

S_L = {s : every pair (i,j) in s satisfies j - i < L}.

span --span L returns the exact ViennaRNA 2.7.2 MFE over S_L for its supported model envelope. It removes no state because of its score. Therefore, for L1 <= L2,

E_exact <= E_span(L2) <= E_span(L1).

When L >= n, span has the same optimal energy as global exact MFE. Tied dot-bracket structures may differ. The implementation also handles arbitrary unpaired multiloop flanks; Vienna's 30-nt MAXLOOP restriction applies only to bulges and internal loops.

At fixed L, the bounded state width makes runtime near-linear in sequence length. The conservative worst-case bound is O(n L²) time and O(n L) traceback memory. Oversized values are capped internally at n.

span-shift folds deterministic cyclic rotations within the same span, maps each candidate back to the original linear backbone, rejects crossing or model-invalid mappings, evaluates every survivor on the original backbone, and returns the lowest-energy candidate. Cut zero is always included, hence

E_exact <= E_span-shift(L,k) <= E_span(L).

It is not exact within the original-coordinate span: a short pair in a rotation can map to a long pair in the original sequence. --span-shifts 1 is exactly ordinary span. A different shift count creates a different deterministic portfolio; only inclusion of ordinary span is guaranteed, not monotonicity in the number of shifts.

Beam behavior

The beam engines implement a deterministic left-to-right recurrence based on LinearFold, using the active ViennaRNA 2.7.2 parameter object and loop evaluators. Selected structures are scored again with RNAlib, so reported energies are genuine Vienna evaluations even though the search is approximate.

The implementation uses contiguous flat hash beams, nth_element pruning, multiloop candidate/cube pruning, a 4-ary heap, eager future-beam bounds, and release of finalized indexes. beam-fast additionally applies rank-adaptive internal-loop work. Both remain available unchanged.

All four opt-in non-global engines are currently MFE-only and support one linear strand, dangles 0 or 2, lonely pairs and GU closures enabled, no hard/SHAPE constraint, and no G-quadruplex. Temperature, salt, --noGU, special-hairpin control, and model maximum pair span are supported. Unsupported requests receive a clear error and can be run unchanged with --engine exact.

“Exact” means exactness under the supported ViennaRNA 2.7.2 thermodynamic model, not certainty about an RNA molecule's biological structure.

Build

Requirements are a C++20 compiler, GCC-compatible C toolchain, GNU Make, Bash, curl, tar, and patch.

make vendor-exact
make -j
make check

The default build uses -march=native, LTO, OpenMP linkage, and the SIMD level of the build host. Build both RNAlib and RiboFlare without host-specific instructions with:

make profile-portable -j

That produces bin/riboflare-portable. Setting NATIVE=0 only on the final C++ build is insufficient if RNAlib was already compiled for the native host.

The prebuilt archive contains both executables. bin/riboflare is the benchmarked Zen 4-native build; use bin/riboflare-portable on other x86-64 systems or when the available instruction set is unknown.

make profile-floatpf retains the optional Vienna float-PF build. It can reduce partition-matrix memory, with small floating-point differences, but is not the default because it was slower on the development host.

CLI examples

Fast joint stability/CAI design for one protein, using all available cores:

printf '%s\n' MNDTEAI | \
  riboflare design --mode fast --lambda 1 --engine beam-fast -j 0 --json

Exact-oracle design (particularly useful for short proteins or validation):

riboflare design --mode balanced --engine exact proteins.fa

Maximum-throughput bounded-span design with a custom host table:

riboflare design --engine span --span 70 \
  --codon-usage host-codons.csv --lambda 3 proteins.fa

Design a fixed leader, a free switch, and a synonymous CDS while opening the first six CDS nucleotides and favoring a leader/switch interaction:

riboflare design --format jsonl --json <<'JSONL'
{"id":"switch","segments":[{"id":"leader","type":"fixed","sequence":"GGGAAACCC"},{"id":"switch","type":"free","length":12},{"id":"cds","type":"coding","protein":"MNDTEAI"}],"regions":[{"id":"cds-start","segment":"cds","start":0,"end":6}],"objectives":[{"region":"cds-start","goal":"minimize","weight":1.5},{"region_a":"leader","region_b":"switch","goal":"maximize","weight":2}],"engine":"exact","top_k":8,"pareto":true,"min_hamming_fraction":0.05}
JSONL

design uses protein FASTA/lines/JSONL, whereas fold uses RNA input. No stop codon is added implicitly; include terminal * in the protein when one should be designed.

Exact MFE for a FASTA batch, using eight record workers:

riboflare fold --mfe-only -j 8 sequences.fa

High-fidelity approximate MFE for unrestricted long RNAs:

riboflare fold --engine beam --beam 200 long-rnas.fa

Faster beam search:

riboflare fold --engine beam-fast --beam 100 --json long-rnas.fa

Exact MFE under a 70-nt pair-span restriction:

riboflare fold --engine span --span 70 --json long-rnas.fa

Try four cyclic cuts while retaining every ordinary span candidate:

riboflare fold --engine span-shift --span 40 --span-shifts 4 long-rnas.fa

Sliding-window MFE, local pair probabilities, and unpaired-stretch accessibility through length 30:

riboflare local --window 200 --span 120 --bpp --unpaired 30 \
  --cutoff 0.01 --json long-rnas.fa

local uses ViennaRNA's native window recurrences; it does not independently refold every substring. Its coordinates are one-based, matching RNALfold and RNAplfold conventions. Use --no-mfe for probability/accessibility-only work.

The beam knobs are --beam, --beam-max-loop, --beam-short-loop, and --beam-long-loop-states. The non-beam knobs are --span and --span-shifts. Increasing any search budget costs throughput and memory; only increasing --span has the nested-search-space exactness guarantee above.

Full ensemble analysis as ordered JSONL:

riboflare fold --ensemble --cutoff 0.01 --json -j 8 sequences.fa

Hard-constrained MFE:

printf '%s\n' GCGCUUCGCC | riboflare fold --constraint 'xxx....xxx'

Score a supplied structure:

riboflare eval GCGCUUCGCC '(((...))).'

Run riboflare --help for all CLI and JSONL controls.

C++ API

#include <riboflare/riboflare.hpp>

riboflare::FoldRequest request;
request.id = "candidate-1";
request.sequence = "GCGCUUCGCC";
request.search.engine = riboflare::FoldingEngine::span;
request.search.pair_span = 70;

const riboflare::FoldResult result = riboflare::fold(request);

Design is a separate additive API:

riboflare::DesignRequest request;
request.id = "antigen";
request.protein = "MNDTEAI";
request.cai_weight = 1.0;
request.search.mode = riboflare::DesignMode::balanced;
request.search.folding.engine = riboflare::FoldingEngine::beam_fast;

const riboflare::DesignResult result = riboflare::design(request);

The same API supports mixed constructs and pair-targeted design:

riboflare::DesignRequest request;
request.segments = {
    {"leader", riboflare::DesignSegmentKind::fixed, "GGGAAACCC"},
    {"switch", riboflare::DesignSegmentKind::free, "", 12, "ACGU"},
    {"cds", riboflare::DesignSegmentKind::coding, "MNDTEAI"},
};
request.regions = {{"start", "cds", 0, 6}};
request.interaction_objectives = {
    {"start", "", riboflare::InteractionGoal::minimize, 1.5},
    {"leader", "switch", riboflare::InteractionGoal::maximize, 2.0},
};
request.search.folding.engine = riboflare::FoldingEngine::exact;
request.search.top_k = 8;
request.search.pareto = true;

const riboflare::DesignResult result = riboflare::design(request);

Local analysis is additive as well:

riboflare::LocalRequest request;
request.sequence = "GGGAAACCC";
request.analysis.window_size = 9;
request.analysis.pair_span = 9;
request.analysis.base_pair_probabilities = true;
request.analysis.unpaired_length = 3;

const riboflare::LocalResult result = riboflare::local_fold(request);

human_codon_usage(), normalize_protein(), and translate_rna() are also public. Supplying DesignRequest::codon_usage replaces the built-in human table and can restrict the synonymous lattice.

Omitting FoldRequest::search selects exact folding, as in earlier releases. FoldResult reports the engine and the beam/span settings actually used; result.approximate() is true for any explicitly selected non-global engine. DesignRequest instead defaults its internal oracle to beam-fast.

fold_batch(), evaluate_batch(), design_batch(), and local_fold_batch() preserve input order. Passing jobs = 0 uses the available hardware threads and schedules longer sequences first. RiboFlare patches ViennaRNA 2.7.2's parameter-object caches to be thread-local, so mixed-model batches remain deterministic without serializing parameter construction or folding work.

The lightweight libriboflare.a contains the RiboFlare objects; applications link it with the matching RNAlib archive and -fopenmp -lm. make vendor-exact materializes that dependency under third_party/vienna-exact.

Validation

The integration suite contains 41 test groups. With official reference executables configured, all 41 run and cover:

• 840 randomized exact-MFE comparisons against ViennaRNA 2.7.2 across seven model modes;
• 1,080 randomized exact-vs-span comparisons across three width limits and five model modes, plus a long-multiloop-flank regression;
• 120 specialized/general MFE and 120 specialized/general PF comparisons, including temperature, salt, dangles, no-GU, and mixed-model requests;
• ensemble free energy, MFE probability, centroid, MEA, and diversity parity;
• 30 RNAeval comparisons;
• hard constraints, SHAPE data, multistrand evaluation, and sampling;
• all five CLI/API engine selections, metadata, Vienna rescoring, dot-bracket validity, span monotonicity, and span-shift dominance;
• ordered serial/parallel determinism, including deliberately mixed Vienna model settings, and per-record error isolation;
• published short LinearDesign behavior, exact tiny-lattice enumeration, translation invariants, CAI scalarization, custom codon restrictions, all five design oracles, best-seed dominance, and serial/parallel design parity;
• mixed coding/fixed/free lattice invariants and alphabet restrictions; explicit subregions using both end and length, exact regional opening and closing, exact and beam-fast cross-region stem targeting, and pair avoidance;
• diverse top-k Hamming separation and three-axis Pareto non-dominance;
• local MFE, probability-only operation, unpaired-stretch identities, local/global BPP equality in the unrestricted-window limit, and ordered serial/parallel local determinism;
• target-conditioned design energies independently re-evaluated after removal of all structural pseudoenergies.

The same suite passes the native build, portable build, and a -fsanitize=undefined build. make check also compiles and executes a public C++ API smoke program covering legacy design, segmented pair targeting, global folding, and local probabilities.

Configure the references for the full differential suite:

RIBOFLARE_BIN="$PWD/bin/riboflare" \
RNAFOLD_BIN=/path/to/RNAfold \
RNAEVAL_BIN=/path/to/RNAeval \
python3 tests/test_integration.py

Measured performance and trade-offs

The 0.9 benchmark uses a free-region / fixed-loop / free-region construct with a maximum cross-region-pair objective. Each top-1 run performs four oracle folds. Both engines recover every possible cross-region pair; the exact path places target energies inside the recurrence, while beam-fast uses the guided approximate search.

RNA length	Exact targeted design	Beam-fast targeted design	Cross-pairs
60 nt	0.0105 s	0.0066 s	28 / 28
120 nt	0.0362 s	0.0132 s	58 / 58
240 nt	0.1597 s	0.0277 s	118 / 118

At 120 nt, beam-fast top-1 took 0.0123 s. Requesting eight diverse results expanded the retained population and performed 20 folds, taking 0.0819 s. Pareto filtering has negligible cost relative to those oracle calls; this single-axis free-RNA example has only one non-dominated result.

Native local-window timings with window 150, pair span 100, and accessibility through length 30 were:

RNA length	Local MFE	BPP + accessibility	Combined
1,000 nt	0.134 s	0.400 s	0.540 s
3,000 nt	0.398 s	1.202 s	1.602 s

The near-linear scaling comes from ViennaRNA's sliding recurrences. Combined analysis shares one encoded/model-parameterized fold compound instead of constructing separate common state for MFE and probabilities. Reproduce both tables with:

python3 benchmarks/benchmark_regions_local.py --riboflare bin/riboflare \
  --repeats 3

The design benchmark below uses deterministic random proteins, the built-in human codon table, lambda=0, beam-fast 100, all available candidate workers, and three end-to-end repetitions on the same native Zen 4 host. “Gain” is the energy improvement over folding the maximum-CAI synonymous sequence with the same oracle; because that seed is always retained, the gain cannot be negative.

Protein length	Mode	Time	Best energy	CAI	Gain vs CAI seed	Oracle folds
100 aa	fast	0.082 s	−134.7	0.9838	10.4 kcal/mol	6
100 aa	balanced	0.115 s	−134.7	0.9838	10.4 kcal/mol	14
300 aa	fast	0.289 s	−379.7	0.9542	64.2 kcal/mol	7
300 aa	balanced	0.415 s	−379.7	0.9542	64.2 kcal/mol	17
1,000 aa	fast	1.103 s	−1,275.8	0.9630	212.1 kcal/mol	6
1,000 aa	balanced	1.521 s	−1,277.6	0.9608	213.9 kcal/mol	16

On a separate deterministic 1,000-aa input, balanced design took 5.879 s with one worker and 1.576 s with automatic candidate parallelism. These measurements are not a direct hardware-matched comparison with the LinearDesign paper's reported spike-protein runtime; they establish the behavior of this artifact.

Reproduce the table with:

python3 benchmarks/benchmark_design.py --riboflare bin/riboflare \
  --lengths 100,300,1000 --modes fast,balanced \
  --engine beam-fast --lambda 0 --jobs 0 --repeats 3

The deterministic end-to-end benchmark includes startup, parsing, folding, traceback, Vienna rescoring, and output. On the native znver4 development host:

Length	Exact	Beam 100	Beam-fast 100	Span 40	Span 70	Shift 40 × 4
200 nt	0.0095 s	0.0298 s	0.0156 s	0.0075 s	0.0163 s	0.0216 s
1,000 nt	0.1590 s	0.3271 s	0.1071 s	0.0270 s	0.0801 s	0.0987 s
3,000 nt	2.0829 s	1.2283 s	0.3717 s	0.0807 s	0.2532 s	0.3188 s
10,000 nt	not run	4.3470 s	1.3092 s	0.2700 s	0.8573 s	1.0320 s

At 10,000 nt, span 40 was 4.85× faster than beam-fast 100; span 70 was 1.53× faster; shift 40 × 4 was 1.27× faster.

The price of a hard span bound is explicit. On 96 deterministic random sequences of length 80–500:

Engine	Mean energy gap	Max gap	Mean pair F1
Beam 100	0.1698 kcal/mol	3.5	0.9388
Beam-fast 100	0.2146 kcal/mol	3.5	0.9211
Span 40	19.8740 kcal/mol	44.3	0.3641
Span 70	11.2948 kcal/mol	27.1	0.4856
Shift 40 × 4	16.2604 kcal/mol	41.8	0.3905
Shift 70 × 4	9.2469 kcal/mol	25.0	0.5117

Use a beam engine when general all-span accuracy is the priority. Use span when locality is part of the intended model or when its much lower fixed-width cost matters more than long-range pairs. span-shift improves the same-width energy by construction, but a single wider span may be a better speed/quality trade-off for many workloads.

Reproduce the non-beam benchmark with:

python3 benchmarks/benchmark_beam.py \
  --riboflare bin/riboflare \
  --beam 100 --spans 40,70 --span-shifts 4 \
  --repeats 3 --accuracy-records 96

The exact/PF benchmark against official RNAfold remains available:

python3 benchmarks/benchmark.py \
  --rnafold /path/to/RNAfold \
  --records 96 --min-length 160 --max-length 260 --jobs 8 --repeats 7

Measured on the same host against official ViennaRNA 2.7.2 RNAfold:

Workload	RiboFlare	RNAfold	Speedup
Exact MFE, 1 worker	0.526 s	2.728 s	5.19×
Exact MFE, 8 workers	0.085 s	0.420 s	4.92×
PF only, 1 worker	2.508 s	6.001 s	2.39×
PF only, 8 workers	0.437 s	1.071 s	2.45×
Full ensemble, 1 worker	5.129 s	8.268 s	1.61×
Full ensemble, 8 workers	0.769 s	1.386 s	1.80×

These are host- and workload-specific medians, not universal speedup guarantees. The benchmark inputs are generated deterministically by the scripts.

Deliberate scope limits

The following remain outside this core release:

• suboptimal and Zuker-style structure enumeration;
• comparative/alignment folding (RNAalifold);
• duplex concentration calculations and the full RNAcofold workflow;
• exact arbitrary dot-bracket inverse folding, multi-strand/co-transcriptional design, kinetics, and barriers;
• modified nucleotides, motif/restriction-site constraints, codon-pair bias, and wet-lab expression or degradation models;
• SHAPE constraints in the local-window API (global folding still supports Deigan SHAPE pseudoenergies);
• parameter-file loading and command-file scripting;
• plots, PostScript dot plots, and auxiliary ViennaRNA executables;
• pseudoknotted structures, as with standard RNAfold thermodynamics.

span still computes one global MFE under a pair-width restriction. Use the separate local command for RNALfold/RNAplfold-style window output.

The approximate engines do not yet implement a LinearPartition-style PF/BPP path. PF, BPP, centroid, MEA, diversity, and sampling continue to use the exact engine.

Boltzmann sampling is reproducible but serialized internally because ViennaRNA 2.7.2 uses a process-global random generator. Other batch folding work runs concurrently.

License

The original RiboFlare Core code is MIT-licensed in LICENSE. ViennaRNA 2.7.2 uses its own license, reproduced in LICENSE-VIENNARNA; it permits research, educational, and commercial use and modification, but restricts redistribution for a fee and asks users to contact its authors before inclusion in a commercial product. The statically linked binary remains subject to those ViennaRNA terms. See THIRD_PARTY.md before redistributing it.