In a biotech future where strands of DNA are not just blueprints but programmable machines, a bold question arose: could a single circular DNA template be coaxed to generate an entire family of RNA sequences—simply by letting transcription happen and letting the RNA be rearranged as it’s made? The answer, from a team spanning Korea, Japan, and Germany, sits at the crossroads of molecular biology and formal languages. It’s less a magic trick and more a careful mapping of computation onto biology: if you encode the rules of a computer automaton into DNA, can the biology itself spin out every string that automaton accepts?
The study, conducted by Da-Jung Cho (Ajou University, Korea), Szilárd Zsolt Fazekas (Akita University, Japan), Shinnosuke Seki (University of Electro-Communications, Tokyo), and Max Wiedenhöft (Kiel University, Germany), casts a wide net over co-transcriptional splicing and hairpin structures. It builds on a lineage of work showing that RNA can fold and splice in programmable ways while transcription is still in progress. The new twist is to treat splicing like a computational operation and to show that a circular DNA word, through a precise choreography of hairpin deletions and termination signals, can generate exactly the RNA sequences that a given finite automaton would accept. In short: a DNA template can be a programmable launcher for any regular language of RNA strings, under a mathematically well-behaved energy model.
That sounds abstract, but the punchline cuts straight to the heart of molecular programming. If a single template can encode a whole language of outputs, engineers could design DNA systems that autonomously produce, classify, or respond with a structured set of RNA sequences. It’s a conceptual bridge between software-like design and biology’s material realities. And as the authors emphasize, the problem of designing the smallest DNA template for a target language is not just difficult—it’s NP-hard in general. The work therefore does more than propose a possibility; it maps the computational landscape of how hard it might be to realize it in practice, and where practical shortcuts might lie.
To ground this in names and places you can point to at a lab tour, the study’s framing and core constructions come from Ajou University (South Korea), Akita University (Japan), the University of Electro-Communications (Japan), and Kiel University (Germany). The authors listed—Da-Jung Cho, Szilárd Fazekas, Shinnosuke Seki, and Max Wiedenhöft—bring together perspectives from software engineering, molecular biology, and computational theory, which is exactly the blend needed to turn RNA physics into automata theory on a bench. Their work nods to prior breakthroughs in co-transcriptional folding and splicing, then pushes those ideas into a formal language framework: a meticulous way to encode an arbitrary nondeterministic finite automaton (NFA) onto a circular DNA template and let co-transcriptional hairpin deletions realize all and only the sequences the NFA accepts.
Encoding languages into circular DNA templates
The central idea is deceptively simple to state, and wonderfully nontrivial in practice. Any regular language can be described by a finite automaton—think of it as a machine that reads a string of letters from an alphabet and walks through states according to the letters it sees. The researchers show that you can construct a circular DNA word wω (an infinite repetition of a finite word w) and, under a model they call logarithmic hairpin deletion, make the RNA transcripts that emerge from wω precisely the strings in the language L(A) recognized by a given automaton A.
To translate that into biology, they lean on a specific energy model for hairpin structures. In RNA folding, a loop’s energetic penalty grows roughly with the logarithm of its length, which favors the formation of long loops (hairpins) with short stems. This logarithmic-energy model is crucial: it makes certain hairpin configurations energetically viable even when the loop is long, enabling a controlled, parallel splicing story that mirrors how transcription proceeds. The paper introduces the notion of log-hairpin deletion: a formal operation that deletes a segment of a word when a hairpin forms between a left context and a matching right context, leaving behind a shorter word that corresponds to taking a transition in the automaton. A parallel or maximally parallel version allows several deletions to happen at once, modeling the idea that co-transcriptional splicing can progress in a sequence of rapid, consecutive steps as the RNA chain emerges.
High-level takeaway: encode the states and transitions of an automaton into a cleverly designed circular DNA word; use hairpin deletions as the computational steps that “read” input and switch states; terminate when a final state is reached, guaranteeing that only words in the language pop out of the transcription process. This is not just possible in theory; the authors provide a constructive proof—Theorem 5—that such a word w and a suitable deletion model S exist for any given NFA. In other words, for any regular language, there’s a DNA template that, through designed co-transcriptional splicing, yields exactly that language’s RNA strings.
And because every finite language is representable as an NFA, the construction effectively solves the template-design problem for arbitrary target sets of RNA sequences within the logarithmic hairpin framework. The payoff is a rigorous bridge from automata theory to a concrete, testable biology-friendly mechanism. The catch, of course, is that the shorter and simpler the automaton, the smaller and more practical the DNA template can be. The authors don’t pretend this is easy in the lab—minimizing the automaton is itself a hard computational problem—but they map the exact terrain you’d need to traverse if you wanted to attempt it.
What’s more, the work doesn’t stop at the existence of a construction. It actively explores the limits of optimization. They show that minimizing NFAs (and several realistic restricted variants) remains computationally intractable (NP-hard) in broad cases, meaning there’s no easy shortcut to the smallest possible template for a given language. That’s a sober reminder: even if biology can implement a computation, the combinatorial geometry of designing the template can be the real bottleneck. The authors propose steering efforts toward practical language classes and restricted automata forms where efficient minimization might still be within reach, a prudent stance for anyone hoping to translate math into a lab bench.
Simulating finite automata with hairpin deletion
Section by section, the paper builds a rigorous blueprint for how to realize L(A) with a circle of DNA. The key move is to encode each automaton state qi as a block si in the circular word, and to arrange the blocks so that a transition from qi to qj labeled with a symbol a is implemented by a hairpin that deletes everything between the encoded qi and qj, leaving behind the next symbol a and the encoding of the next state. The process is not ad hoc: it relies on a carefully designed context set C that dictates when a hairpin can form, and which left contexts pair with which right contexts to drive the computation forward. The left contexts anchor the choice of the next transition, and the right contexts complete the hairpin, effectively performing the state jump in the physical template.
The authors introduce a terminating mechanism that makes transcription stop at the right moment. In the biological metaphor, after a sequence that ends in a final state, the system can be channeled to a special termination sequence t, via a stem and another contextual handshake. This termination mirrors rho-independent transcription termination in real biology and ensures that the resulting RNA sequences directly correspond to words in L(A), rather than wandering off into unlabeled transcripts.
In more concrete terms, the main result (Theorem 5) states that for any NFA A, there exists a circular word w and a deletion model S such that L(A) equals the language produced by maximal parallel log-hairpin deletion on wω. The paper doesn’t stop at the abstract theorem; Appendix B walks through a concrete encoding for the four-letter RNA alphabet (A, U, C, G), showing how to realize the encoding of a simple two-state automaton. It’s a convincing demonstration that the theory can be instantiated in a biologically plausible alphabet, not just in the realm of pure math.
Crucially, this construction is not an all-purpose blueprint for immediate laboratory deployment. It’s a rigorous existence proof with a careful accounting of what must be designed and how. It clarifies which pieces of the puzzle are essential (the state blocks si, the left/right context pairs, the termination scheme) and which aspects will trip you up in practice (ensuring that hairpins form only at intended positions, avoiding unintended cross-talk, pumping contexts to the right lengths to satisfy energy constraints, and handling the infinite-loop risk if you allow for unbounded computation). Still, the pathway from automaton to circular DNA template is now laid out in a way that researchers can actually try to walk down in a lab setting, with explicit energy-model considerations guiding the design choices.
Why this matters and what it reveals about limits
The most exciting implication is not that biology can “compute” in the abstract sense, but that a single, finite DNA template could be used to generate a potentially infinite family of RNA outputs, all structured by a formal language. If you squint at it, you can imagine DNA templates becoming tiny, programmable engines that manufacture, sort, or respond with strings of RNA in a way that’s dictated by software-like rules. The authors frame this as a step toward programmable molecular systems where co-transcriptional splicing performs computational tasks in real time, directly integrated into the workflow of transcription itself.
Beyond the conceptual novelty, the work also offers practical guardrails. Because the DNA template’s size grows with the automaton’s complexity, the project invites a practical strategy: design target languages that map to compact NFAs or to nicely structured restricted NFAs (like SSB-NFAs, RB-NFAs, and DB-NFAs) where minimizing size might be more tractable. The paper proves that even these restricted models retain NP-hard minimization properties, which is a sober but valuable finding: there are deep computational limits to how small a DNA template can be for a given language, and those limits persist even under reasonable laboratory constraints.
From a broader perspective, the work sits in a strand of research that treats DNA and RNA not as passive carriers of information but as programmable substrates for computation. The idea that a template can “compute” by guiding splicing decisions—on a circle, no less—puts a new spin on ideas that previously lived mainly in theoretical computer science and in the laboratory of synthetic biology. It’s a reminder that the boundary between software and biology is not just eroding; it’s being redrawn with formal languages as a design language for living matter.
Of course, there are open questions that the paper herself flags. Could the hairpin-deletion paradigm extend to more expressive language classes, like context-free languages? What would it take to realize such systems experimentally with current RNA biology tools? And how will real-world thermodynamics, kinetics, and cellular environments shape or constrain the neat, combinatorial picture painted in the theory? The work doesn’t pretend to have all the answers, but it provides a rigorous map that experimentalists can use to guide their next steps—and a theoretical framework that computer scientists can use to reason about what is possible at the molecular scale.
In the end, the paper’s core claim lands with a quiet confidence: a circular DNA template, guided by the right hairpin deletion rules and termination, can realize any regular language’s output. That’s not a one-line boast; it’s a programmatic invitation. The invitation is to design biology with the same precision and ambition that software developers apply to code—only now, the compiler is a looping strand of nucleotides and the runtime is a choreography of RNA splicing as transcription unfolds. If the field continues to develop along this path, we may someday see DNA templates that, literally, spit out RNA documents coded to order and read by the cell as a language well understood by both biology and computation.
Where the work sits in the ecosystem: the study sits at the intersection of RNA biology and automata theory, extending the lineage of programmable co-transcriptional folding into a language-encoding framework. The implications ripple outward toward molecular programming, DNA data storage concepts that rely on regular-language constraints, and the design of RNA-based devices that can perform structured outputs on a programmable schedule. It’s a reminder that computation can be written not only in silicon but in the very chemistry of life, and that formal languages remain a surprisingly effective lens for imagining what that chemistry could someday do.
