# Biological DOOM: a brief overview of biological computation

*(no, not* [*that kind of biological doom*](https://www.nti.org/about/programs-projects/project/global-catastrophic-biological-risks/)*)*

[DOOM](https://en.wikipedia.org/wiki/Doom_(1993_video_game)) is a classic first-person shooter game released in 1993 by id Software. Because it’s from 1993, it doesn’t require much computing power compared to modern games. Additionally, the code (written in C) is easy to compile to run on a variety of processors.

Over the years, hackers have made DOOM run on things such as an [ATM](https://www.youtube.com/watch?v=PW5ELKTivbE), a [touchbar of a MacBook](https://www.youtube.com/watch?v=GD0L46y3IqI), a [Porsche 911,](https://www.youtube.com/watch?v=NRMpNA86e8Q) and even [a TI-84 calculator powered by potato batteries.](https://youtu.be/KFDlVgBMomQ?t=551)

But what about cells?

Requirements for DOOM
---------------------

The [inputs to DOOM](https://gaming.stackexchange.com/questions/363261/what-are-the-original-controls-of-doom-1993) are based on button presses, traditionally on a keyboard. 9 keys in total are required (assuming “switch weapon” is implemented as one key that cycles through weapons).

For computation, the original 1993 release required:

*   [4 MB of RAM and 12 MB of hard-drive storage](https://www.reddit.com/r/gaming/comments/a4yi5t/original_doom_system_requirements_from_my_25_year/)
*   [Intel 386 (bare minimum) or 486 processor](http://ps-2.kev009.com/pcpartnerinfo/ctstips/f4a2.htm).

There is some flexibility regarding the processor, but slower processors will have worse frame-rates. The Intel 386 had 275,000 transistors in its most basic configuration.

DOOM also requires a graphical output. The smallest resolution I’ve seen is [128x32 pixels](https://twitter.com/Foone/status/1302820468819288066), and that was cutting it a bit close. We’ll assume we need 4096 black-and-white pixels for the display.

Finally, DOOM has audio. For the purposes of this thought experiment, we can ignore this output. Although the soundtrack is great, it’s not strictly required to play the game.

Approaches to biological computation
------------------------------------

So, how could we potentially run DOOM? Biological systems can perform computations in several ways:

**Nucleic acid hybridization**

These logic gates are based on strand displacement between complementary DNA sequences.[^2t2imzayjni] [A recent paper](https://pubs.acs.org/doi/10.1021/jacs.2c03258) demonstrated a set of DNA-based logic gates that could add two 6-bit binary numbers.

![](https://substackcdn.com/image/fetch/w_1456,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fe375c10e-1de5-4d99-b8de-9c93fc067bd1_1924x806.png)

A DNA-based AND gate, from the paper. The output Oab is released only if both inputs A and B are present. This can also be reconfigured to work as an XOR gate.

Pros and cons:

*   Memory capacity is good (encoded in DNA or RNA)
*   Switching speed is OK (rate constants vary by design but are [typically around](https://pubs.acs.org/doi/full/10.1021/ja906987s) $10^6 M^{-1} s^{-1}$)
*   Visual output could be provided by fluorophore/quencher conjugated oligonucleotides, but . . .
*   Coupling to a macroscopic output display would be far too slow, because it would have to rely on diffusion (taking a few minutes to cover a millimeter-scale distance). So, the game would have to be played using a microscope.
*   It’s hard to “reset” gates after using them, this requires coupling to some energy source
*   It’s also hard to integrate DNA-based logic gates into other biological systems, since not many organisms use short pieces of ssDNA. RNA might be used instead.

**Transcription and translation**

These logic gates use the same tools that cells use to regulate gene expression. For example, the classic *lac* operon in bacteria implements:

    if(high_lactose and not (high_glucose)):
        transcribe([lacZ, lacY, lacA])

Biologists have exploited similar systems to build logic gates, as well as systems involving the regulation of translation (the production of proteins using mRNAs as templates). A [recent paper](https://www.nature.com/articles/s41467-023-37540-7) used Cas9 binding to a sgRNA-like sequence inserted in an mRNA to control its translation. To form a NAND gate, they split Cas9 into two fragments; if both were present, the output protein was not produced.

[![](https://substackcdn.com/image/fetch/w_1456,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F38092e30-0439-4fc9-a1cc-3795fe7ec4da_1488x736.png)](https://substackcdn.com/image/fetch/f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F38092e30-0439-4fc9-a1cc-3795fe7ec4da_1488x736.png)

Pros and cons:

*   Memory capacity is acceptable (encoded in DNA or RNA)
*   There will be challenges with implementing the number of logic gates required while avoiding cross-talk
*   The **dealbreaker**: far too slow to run DOOM. RNA and protein half-lives are on the order of minutes to hours.

**Protein phosphorylation (kinases/phosphatases)**

Many cell signaling pathways use protein phosphorylation as a signal. This is much faster than transcription and translation, since no new RNAs or proteins need to be produced. A [paper in 2021](https://doi.org/10.1126/science.aav0780) built a toggle switch in yeast out of several kinases and phosphatases.

![An external file that holds a picture, illustration, etc.
Object name is nihms-1723091-f0001.jpg](https://substackcdn.com/image/fetch/w_1456,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F075f283c-c80a-4062-8c83-1dc379b933cb_899x518.jpeg)

Nuclear localization of GFP could be toggled on by adding sorbitol, or off by adding isopentenyl adenine. “The toggle is ultrasensitive, can be induced to switch states in seconds, and exhibits long-term bistability.”

Pros and cons:

*   Response speed is adequate, similar to nucleic acid hybridization gates (i.e., largely limited by diffusion)
*   Unlike with nucleic acid hybridization gates, it’s quite easy to reset gates after using them
*   Visual output could be provided by luciferase
*   Hard to implement the number of logic gates required while avoiding cross-talk (although [efforts in *de novo* protein design may improve this](https://www.bakerlab.org/2020/04/02/de-novo-design-protein-logic-gates/))
*   Also very hard to implement large amounts of memory

**Electrical computation (nerves)**

In general, biological computation based on chemicals is tricky. With individual molecules acting as signals, there isn’t a good way to make “wires” to limit crosstalk and communicate faster than diffusion. The closest thing is scaffold proteins for kinases, but those are rather limited in what they can accomplish.

Instead, evolution has harnessed electricity for rapid, specific communication between cells. Neurons can transmit electrical signals on millisecond timescales over meter-scale distances. Of course, neurons also use chemical computation as well. Your brain is an example of a computer that can *play* DOOM; it could probably also run DOOM under the right conditions.

![https://www.frontiersin.org/files/Articles/1017235/fsci-01-1017235-HTML-r8/image_m/fsci-01-1017235-t001.jpg](https://substackcdn.com/image/fetch/w_1456,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F78b7d7a6-2e79-4e4f-b61d-eb1f2adc4993_772x792.jpeg)

Table from [a recent review](https://www.frontiersin.org/journals/science/articles/10.3389/fsci.2023.1017235) of the prospects for neural organoid computing.

Pros and cons:

*   Response speed is excellent
*   Good feasibility for coupling to inputs using electrodes. Optogenetics or mechanosensory neurons would also be very useful here.
*   Outputs could be provided by [chromatophores](https://en.wikipedia.org/wiki/Chromatophore#Cephalopod_chromatophores)
*   Good amount of memory available
*   Very hard to precisely engineer. You’d probably have to grow a neural organoid, and then *train* it somehow to run DOOM. Perhaps you could do some sort of reinforcement learning to “predict the next frame” given the game state and user input. But I don’t think there are any good current methods for training an organoid.

I would really love to play DOOM on a cuttlefish. Paging [Peter Watts!](https://www.rifters.com/real/author.htm)

Prospects for DOOM
------------------

Overall I think that either neurons or protein phosphorylation logic are the best candidates for running DOOM. Neurons can clearly do it, but programming/training them will be quite difficult, and anything I write about that is wild speculation.

So, let me speculate less wildly about protein logic. Here, the main limit will be the RAM required. If a molecule can store one bit of information (such as a protein being phosphorylated or not), then to store 4 megabytes will require slightly under 34 million molecules. And to increase robustness, it would be a good idea to use multiple molecules per bit.

Across many different organisms, [cells tend to contain 2 – 4 million protein molecules per cubic micron](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3910158/). So, a bacterial cell will have about 2 million proteins, a yeast cell will have about 50 million, and a mammalian cell will have about 2 billion (depending on the cell type). You probably couldn’t run DOOM on a bacterial or yeast cell, but it could be possible to use a human cell.

The most straightforward way of setting up this RAM would require having each bit of memory correspond to a unique molecular species. Assuming you could encode one unique molecule per 1000 bases of DNA[^8h537pcxh0l], this would take 34 billion bases. This is too big for a human cell (which has 6.6 billion bases for a diploid cell), but an axolotl (64 billion bases) or African lungfish ([80 billion](https://www.cell.com/cell/pdf/S0092-8674(21)00090-8.pdf)) might be able to handle it. Using RNA, or smaller proteins, as information carriers could probably reduce the required DNA to 200 – 500 bases per unique molecule. But this is still quite a lot of DNA, far too much to synthesize and assemble using current technology.

To reduce the DNA required, it might be better to not use unique molecules, and instead have some system of spatial separation preventing crosstalk between different bits of memory. Using multiple cells would be the obvious approach. However, this would increase the complexity of the rest of the design. The DOOM code might also be optimized to require less RAM, but I’m not sure how feasible this would be. A more promising approach would be to have each molecule carry more than one bit of information. For proteins, this could be accomplished by having multiple possible phosphorylation sites, and having the interaction partners be site-specific.

Given that biomolecules such as proteins can act as both information storage and logic gates, I think that if the RAM can be built, the logic gates should be easier in comparison.[^biuesz31zd] Even though the switching times will be slower than the 12 to 40 MHz of an Intel 386, all the RAM addresses could be operated on at once, so hopefully it will be possible to parallelize most of the calculations. Overall, I don’t think speed will be an issue, given that many protein kinases can perform a phosphorylation every 10ms,[^u4gylou71ym] and higher rates could be achieved by engineering.

In conclusion, although it may be possible to run DOOM in an individual animal cell,[^b47ppbhyqct] it is not achievable with current technology. Using neurons is a promising idea, but we have no good way to program/train them. The best approach may be to combine these logic systems, and have a few dozens to hundreds of neurons linked together in a pre-defined connectome, with each neuron using protein phosphorylation or nucleic acid hybridization logic to precisely specify its signaling.

What about something simpler?
-----------------------------

How about Pong?

Pong was released in 1972 (21 years before DOOM) and [can be implemented](http://searle.x10host.com/TeleTennis/PWTennis.html) with the following components (not counting the cathode-ray display tube):

![](https://substackcdn.com/image/fetch/w_1456,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F2ec368b0-9483-4619-bcc1-0def7dd9897f_722x932.png)

The most complicated things here are the NE555 chips, more commonly known as [555 timers](https://en.wikipedia.org/wiki/555_timer_IC). I remember playing around with them as a kid.

If synthetic biologists really wanted, I think that we could probably make Pong run on cells with current technology. Or for the ultimate meta experience, how about running [Conway’s Game of Life](https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life) . . . on life!

*Note, I am a biologist, not an expert on old video games. If there is any incorrect information in this post, please let me know!*

[^2t2imzayjni]: Also, this could be done with RNA. People work with DNA oligos since they’re easier. 

[^8h537pcxh0l]: This would encode a medium-size protein, including a promoter and other regulatory sequences. 

[^biuesz31zd]: Which is to say, still very difficult. 

[^u4gylou71ym]: This is expressed as \(k_{cat} =\) 100 \(s^{-1}\) 

[^b47ppbhyqct]: Another limitation of running in an individual cell is the output. The diffraction limit of light means that a microscopic display the size of a cell can’t have the necessary resolution.