23 Open Problems for Digital Self-Replicators
                                              by Second Part To Hell
Who of us would not be glad to lift the veil behind which the future lies
hidden; to cast a glance at the next advances of our field and at the secrets of
its development during future centuries? What particular goals will there be
toward which the leading pioneers of digital self-replicators of coming
generations will strive? What new methods and new facts in the wide and rich
field of intelligent artificial self-replicators will the future bring to light?
These words are inspired by the introductory remarks of David Hilbert's speech,
delivered at the International Congress of Mathematicians in Paris in 1900. He
proceeded to introduce 23 open mathematical challenges, which profoundly
influenced mathematical research throughout the 20th century.
Today, I take the opportunity to present a compilation of 23 crucial challenges
in the realm of digital self-replicators, computer viruses, and worms. I find
each of these challenges deeply fascinating. Their underlying motivations,
background, and preliminary pathways toward resolution are detailed herein,
along with my view of their potential (or partial) solutions.
With this list, I aim to inspire the upcoming generation of programmers. Those
of you passionate about artificial intelligence, evolution, and the essence of
life should dive deep into these significant challenges. I truly believe that
solving these problems will make a lasting difference. To keep track of our
collective progress, I've set up a page on my site (https://github.com/SPTHvx/).
I look forward to seeing your contributions and am keen to share your successes.
Metamorphism and Advanced Mutation Techniques:
  1) Strong Metamorphism and Macro-Mutations via Large Language Models
  2) Metamorphism as a Deep Reinforcement Learning problem
  3) Highly expressive mutation engines inspired by natural evolution
  4) Auto-generated mutation engines via Large Language Models
  5) Exploring the power of Linguisto-Morphism
  6) Dynamic Behavioral Mutation in Self-Replicators
  7) In-Built Large Language Models in Self-Replicators
  8) Encoding the virus code in pictures
Adaptive Self-Defense:
  9) Learning to evade detection for specific AVs
  10) Discoving and memorizing new reliable anti-emulation tricks
  11) Learning API useage for self-replicators
Frontiers of Infection & Replication:
  12) Multi-file infection via Large Language Models
  13) Spreading in unconventional computing schemes
  14) Infection of Quantum Computers
  15) Full Biological-Digital Cross-Infections
  16) Self-Replicating Machines
  17) Mutation engines for Self-Replicating Machines
Communication, Curiosity and Consciousness:
  18) Automated Social Engineering with provable benefit
  19) Financial Autonomy for Self-Replicators
  20) Intrinsically Motivated, Curiousity-Driven Self-Replicator
  21) Collaborative Swarms of Self-Replicators
  22) Harnessing Brain-Computer Interfaces for Digital Self-Replicators
  23) Self-awareness and Consciousness in Digital Self-Replicators
Disclaimer: This list is a collection of possibilities in our new age of
advanced artificial intelligence. Each point is an important intellectual
challenge for the curios mind. We detest people who use botnets, banking
trojans, spammin bots or randomsomware to earn money and harm people. These are
criminals and should be punished.
  - - - - - - - - - - - - - - - - - - - - - - - -
1) Strong Metamorphism via Large Language Models: From Micro to Macro Mutations
The rise of publicly accessible, advanced AI models like GPT has not only
astounded many but has also ushered in novel mutation techniques for viruses.
Rather than crafting our own mutation engines, such as metamorphic engines,
viruses can now directly request tools like GPT to produce new code and
functionalities for their succeeding iterations via their APIs. I showcased this
capability for the first time in March 2023 [1]. However, these initial codes
merely scratch the surface. Due to the constraints of the foundational GPT
model, such as text-davinci003, there's an inherent limitation to the code's
variability. I went a step further in LLMorpher3, where also prompts are
generated by GPT -- using GPT4. But the system was still extremely brittle and
at no way at a level of hand-crafted metamorphism engines[2].
This brings us to an intriguing question: How can artificial self-replicators
leverage LLMs to achieve metamorphism on par with powerful metamorphic viruses
like Win.MetaPHOR [3] or JS.Transcriptase [4]? Can we move past micro-mutations
and pioneer macro-mutators, which can transform extensive logic blocks, not just
code snippets [5]? Where do we draw the line?
With tools like Github Copilot excelling in macro-logic coding tasks, it's
imperative to explore their potential for virus metamorphism.
- Partial Solution: Emergence of a virus with high metamorphism that surpasses
the sophistication of MetaPHOR or Transcriptase.
- Full Solution: Development of macro-level mutators that go beyond mutating
isolated standalone functions.
[1] SPTH, "Using GPT to encode and mutate computer viruses entirely in natural language ",
https://github.com/SPTHvx/SPTH/blob/master/articles/files/LLMorpher.txt, 2023.
[2] SPTH, "Full Metamorphism of computer virus code and prompts via GPT4",
https://github.com/SPTHvx/SPTH/blob/master/articles/files/LLMorpher.txt, 2023.
[3] Mental Driller, "Metamorphism in practice", 29a#6, 2002.
[4] SPTH, "Metamorphism and Self-Compilation in JavaScript",
valhalla#3, 2012.
[5] herm1t, "Recompiling the Metamorphism", valhalla#2, 2012. 
  - - - - - - - - - - - - - - - - - - - - - - - -
2) Metamorphism as a Deep Reinforcement Learning problem
DeepMind showcased how a Reinforcement Learning (RL) agent could unearth new and
efficient sorting methods. These have even been adopted into the standard C++
sort library of LLVM [1]. They set up the sorting task like a game, where
rewards are sparse, and had their agent, AlphaDev, learn it. Imagine applying a
similar approach to discovering fresh code versions for self-replicators. This
could open doors to mutations beyond a programmer's wildest imagination. There
are, of course, questions about resources, but we'll address that later.
- Solution: Development of the first Deep Reinforcement Learning agent
integrated into a self-replicator for the discovery of new mutations.
[1] DeepMind, "Faster sorting algorithms discovered using deep reinforcement
learning", Nature, 2023.
  - - - - - - - - - - - - - - - - - - - - - - - -
3) Highly expressive mutation engines inspired by natural evolution
Metamorphic engines can reshape code in countless ways. But if we consider the
entire universe of possible code structures, these engines barely scratch the
surface. It's a double-edged sword: while we want self-replicators to retain
their essential functions (including spreading), this restraint also leaves a
vast world of potential unexplored.
Nature offers inspiration here. From single-cell bacteria evolving into
intricate systems like meat-eating plants or intelligent beings such as cats,
all came about due to random mutations and natural selection. No matter how
sophisticated a coded mutation engine might be, it's unlikely to replicate the
profound changes we see in nature's DNA blueprint. Note that we are not talking
about evolutionary optimization algorithms (such as used in W32.Zellome [1]), we
seek something more extreme.
Purely random mutations might not be the perfect fit for digital evolution
because of their inherent instability. With nature as a guide, scientists have
created stable digital evolutionary systems. Thomas S. Ray's work [2,3]
introduced an "artificial chemistry"—a set of clear instructions capable of
assembling self-replicators that fight for limited resources in a virtual
environment. His creation, the Tierra system, had a sturdy language that
minimized mutation's adverse effects. This foundation allowed more mutations to
stack up, resulting in novel behaviors, like digital parasites. Others, like
Christoph Adami, expanded on this with advanced simulators [4,5].
Yet, these digital entities remain confined within their virtual world. Around
2010-2011, I ventured to bring them to life in real-world systems, guided by
Ray's vision of a resilient evolutionary language. The resulting entities,
Evoris and Evolus, could navigate native win32 environments [6,7], and their
nature was deeply examined by Peter Ferrie [8-10].
Despite their potential to explore beyond conventional metamorphic engines,
Evoris and Evolus are fragile and rely heavily on their in-built mutation
engine. It remains a challenge to transfer the principles from biological
evolution and Ray's 30-year-old virtual-world adaptations to self-replicators in
real-world OSs like Windows or Linux. One possible path? Simulators that test
millions of mutation variations and choose the fittest for reproduction.
- Solution: Development of a mutation engine that accesses a broader code space
compared to traditional metamorphic mutators, yet with greater robustness than
[1] Peter Ferrie, "It's zell(d)ome the one you expect", Virus Bulletin, May 2005.
[2] Tom S. Ray, "An approach to the synthesis of life", Physica D, 1992.
[3] Tom S. Ray, "An evolutionary approach to synthetic biology: Zen and the art
of creating life", Artificial Life, 1993.
[4] Christph Adami, "Introduction to Artificial Life", Springer, 1998.
[5] Richard E. Lenski, Charles Ofria, Robert T. Pennock & Christoph Adami, "The
evolutionary origin of complex features", Nature, 2003.
[6] SPTH, "Taking the redpill: Artifcial Evolution in native x86 systems" 2010.
[7] SPTH, "Imitation of Life: Advanced system for native Artificial Evolution",
valhalla#1, 2011.
[8] Peter Ferrie, "Flibi Night", Virus Bulletin, March 2011.
[9] Peter Ferrie, "Flibi: Evolution", Virus Bulletin, May 2011.
[10] Peter Ferrie, "Flibi: Reloaded", Virus Bulletin, November 2011.
  - - - - - - - - - - - - - - - - - - - - - - - -
4) Auto-generated mutation engines via Large Language Models
My LLMorpher research showcased the capability of a self-replicator to leverage
GPT for evolving its code, albeit with a constant need for OpenAI access [1]. An
intriguing alternative would be harnessing GPT temporarily to devise independent
mutation engines. These engines, once crafted, would then operate autonomously
in the future generations of the self-replicator, eliminating the need for
consistent access to the LLM. I've observed even GPT 3.5 can craft basic
mutation functionalities, and I anticipate future LLMs to be exponentially
proficient in this regard. The challenge lies in seamlessly integrating these
auto-generated engines into subsequent generations of the self-replicator.
- Solution: Development of a self-replicator that can derive new stand-alone
mutation engines from LLMs and effectively incorporate them into subsequent
generation offspring.
[1] SPTH, "Using GPT to encode and mutate computer viruses entirely in natural
https://github.com/SPTHvx/SPTH/blob/master/articles/files/LLMorpher.txt, 2023.
  - - - - - - - - - - - - - - - - - - - - - - - -
5) Exploring the power of Linguisto-Morphism
In my LLMorpher research, I illustrated the capability to encode computer codes
into natural language. These textual representations were then interpreted and
transformed back into executable code by GPT. Advancing this approach in
LLMorpher2, I demonstrated how GPT could not only produce variant codes but also
adapt and modify the English narratives that describe those codes. This
pioneering technique was named "Linguisto-Morphism".
When developing LLMorpher2 in March 2023, I employed text-davinci003. While
powerful, it had constraints, especially when modifying text without altering
the desired outcome. Many promising techniques, in theory, proved fragile in
practice. For instance, converting the language descriptions of code between
different languages was a challenge. This raises an intriguing inquiry: How far
can Linguisto-Morphism truly go? Natural language, with its inherent ambiguity,
seems ripe for generating vastly diverse descriptions that all converge to the
same code execution. What boundaries constrain this methodology? Could
simulation environments aid in amplifying the variability?
- Solution: Development of a self-replicator that, while encoding its own code
in language, can generate highly variable natural language descriptions of its
code without compromising its functionality.
[1] SPTH, "Using GPT to encode and mutate computer viruses entirely in natural
https://github.com/SPTHvx/SPTH/blob/master/articles/files/LLMorpher.txt, 2023.
  - - - - - - - - - - - - - - - - - - - - - - - -
6) Dynamic Behavioral Mutation in Self-Replicators
In most cases, self-replicators have a well-defined behaviour determined by
their computer code, which might change over time. Even the wildest ideas for
macro-mutations, to my knowledge, mainly keep the behaviour of the algorithm
fairly consistent. But how could a self-replicator change its overall behaviour?
The key would be for it to gain and lose complete functions on its own. It would
be fascinating to explore even theoretical concepts on this, much more so to
witness such an engine in action. This question relates to several others on the
list, but I want to mention it separately to emphasize its significance. Here, 
many interesting questions emerge (suggested by Peter Ferrie): How few functions 
would such a replicator need in order to continue functioning? (similar to 
Evoris, and how few unique instructions are needed [1]) How would it (re)gain 
functionality? (How) would it prevent the acquisition of competing functions, or 
would natural selection quickly discard such a variant?
- Solution: Development of a self-replicator that can dynamically learn and
forget non-trivial behaviors, independent of its initial hardcoded instructions.

[1] Peter Ferrie, "Flibi Night", Virus Bulletin, March 2011.
  - - - - - - - - - - - - - - - - - - - - - - - -
7) In-Built Large Language Models in Self-Replicators
For self-replicators, relying on external Large Language Models (LLMs) can be
problematic, especially if there's a risk of access restrictions by providers
like OpenAI. Imagine if they start blocking access or filter out suspicious
A possible solution might be for the self-replicator to carry its own built-in
LLM. Open-source models, such as Huggingface's BLOOM [1] or Meta's Llama 2 [2],
highlighted by Mikko Hypponen [3], might be considered. But, there are some
clear challenges. These models are huge! For example, the smallest Llama2 model
has 7 billion parameters, which translates to 28 gigabytes of data. Spreading
that much data can be hard, and even if possible, it could raise alarms. And big
models need strong hardware, like powerful graphics cards, to work efficiently.
Smaller models, although more manageable, might not be as effective. The big
goal? Have a self-replicator that carries and uses its own LLM to change its
code. Even smaller steps forward, like having built-in LLMs for smarter tricks
against humans (who might not notice small errors like machines do), would be
- Partial Solution: Development of a virus that incorporates its own large
language model for advanced auto-social engineering tasks.
- Full Solution: Realization of a virus that utilizes its own large language
model for mutating its own code, together with a suitable method to transmit the 
virus together with the multi-dozent Gigabyte LLM (P2P? Distributed Computing in 
automated swarms?)
[1] BigScience Workshop, "BLOOM: A 176B-Parameter Open-Access Multilingual
Language Model", arXiv:2211.05100, 2022.
[2] Meta, "Llama 2: Open Foundation and Fine-Tuned Chat Models",
arXiv:2307.09288, 2023.
[3] Mikko Hypponen, "Malware and machine learning: A match made in hell"
https://www.helpnetsecurity.com/2023/04/03/machine-learning-malware/, 2023.
  - - - - - - - - - - - - - - - - - - - - - - - -
8) Encoding the virus code in pictures
Large Language Models, like GPT, have amazed us with their ability to handle
both code and human language, as we demonstrated in LLMorpher. Now, we're on the
brink of even more advanced models that can interact with words, code, and
pictures. Some examples include DeepMind's Flamengo [1] and the
much-talked-about GPT-4 [2], which although showcased publicly, isn't yet
available for hands-on use. These models can understand and manipulate images.
This opens up an intriguing idea - related to the idea of steganography:
what if we hide our virus code within an image, then ask something like Flamengo 
to change the image back into its original code form? Here, the image isn't 
harmful on its own but holds the virus code in a secret way - quite like how in 
LLMorpher, text carried virus functions. Imagine the awe of having a simple .png 
picture, feeding it to a future image-savvy version of GPT, and getting back a 
functioning virus code.
- Solution: Development of the first self-replicator that encodes a significant
portion of its code using images, which are then translated into executable code
by a general-purpose AI.
[1] DeepMind, "Flamingo: a Visual Language Model for Few-Shot Learning",
arXiv:2204.14198, 2022.
[2] OpenAI, "GPT-4 Technical Report", arXiv:2303.08774, 2023.
  - - - - - - - - - - - - - - - - - - - - - - - -
9) Learning to evade detection for specific AVs
Think of a self-replicator that's equipped with a strong mutation tool and a
simulation system. Here's how it could potentially sidestep virus detection: The
self-replicator generates a new version of itself and tests it against the
anti-virus software inside the simulation. If the new virus version gets caught,
the self-replicator uses the mutation tool to create another version and tests
it again. This trial and error continues until the virus successfully goes
unnoticed by the anti-virus.
To achieve this, the mutation tool needs to be really effective. Also, the
self-replicator should be clever enough to break down its own code, figure out
which parts the anti-virus is flagging, and then tweak or hide those parts. I
believe this is a rather challenging problem. It raises interesting questions (
by Peter Ferrie): What if AVs distribute their new signatures only to subsets of 
- Solution: Development of the first self-replicator that operates anti-virus
software within a simulated/virtual environment, testing successive generations
until they are recognized as un-infected.
  - - - - - - - - - - - - - - - - - - - - - - - -
10) Discoving and memorizing new reliable anti-emulation tricks
Anti-emulation and anti-debugging tactics are tools used by codes to avoid being
spotted by behavior analysis, which might flag them as risky or malicious. While
these techniques are generally handcrafted by experts and then integrated into
self-replicators, there's room for automation.
Back in 2012, I delved into a method where such tricks could be found
automatically. By simulating random API interactions and noting down their
undocumented behaviors, the findings were then used as conditions for the next
code generation [1]. However, the approach had its shortcomings. As explained by
Peter Ferrie [2], the method was not stable; many times, these API interactions
behaved differently across various systems, causing the subsequent generations
of code to malfunction.
So, the challenge at hand is: How can we efficiently and stably discover new
anti-emulation techniques in real-time? Could Large Language Models be the key?
Or perhaps Deep Reinforcement Learning or advanced simulation tools?
- Solution: Emergence of the first self-replicator capable of uncovering a broad
spectrum of new anti-emulation strategies and incorporating them effectively
into subsequent generations.
[1] SPTH, "Dynamic Anti-Emulation using Blackbox Analysis", valhalla#2, 2011.
[2] Peter Ferrie, "Is our viruses learning?", Virus Bulletin, 2012.
  - - - - - - - - - - - - - - - - - - - - - - - -
11) Learning API useage for self-replicators
There's a growing interest in training Large Language Models (LLMs) to
independently understand and utilize tools via API calls. A prime example of
this trend is Meta's Toolformer [1], with insightful summaries available on
platforms like Twitter [2]. Think about a self-replicator having the capability
to go through API documentation for systems like Windows or Linux and self-teach
new functionalities. By introducing alternative API calls, it could bring about
significant code changes while retaining the core behavior.
- Solution: Emergence of the first self-replicator capable of learning new API
calls to alter its subsequent generation codes.
[1] Meta, "Toolformer: Language Models Can Teach Themselves to Use Tools",
arXiv:2302.04761, 2023.
[2] Lance Martin/LangChainAI,
https://twitter.com/RLanceMartin/status/1689675201984831491?s=20, 2023.
[3] Susan Zhang, https://twitter.com/suchenzang/status/1690527190985965568?s=20,
  - - - - - - - - - - - - - - - - - - - - - - - -
12) Multi-file infection via Large Language Models
One of the great pursuits in the world of viruses is creating code that can
infect multiple distinct targets. We've witnessed exemplars such as MrSandman
for MacOS and Windows[1], Benny's creation for Windows and Linux[2], Bumblebee's
product for Win32 and Word[3], contributions by roy g biv and hh86 for Win32 and
Win64[4,5], and JPanic's version for Windows, Linux, and MacOS[6].
For interpreted languages, there have been projects to develop such capabilities
too. For instance, consider my JScript+Batch infector [7], roy g biv's
JScript+VBScript approach [8], and my code that leverages a near-universal
metalanguage to infect as many as four languages (JScript+VBScript+Batch+MatLab)
highlighted in [9].
Traditional methods required a significant amount of meticulous manual crafting.
But now, with tools like GPT and its successors that can seamlessly convert
language to code, we could potentially have a program that can adapt and infect
new languages it wasn't initially designed for.
- Solution: Recognition of the first infector targeting JavaScript, Python,
Bash/Shell, PHP, and Rust, utilizing solely LLMs without any language-specific
[1] Mister Sandman, "Esperanto, a multiprocessor and multiplatform virus", in
29a#2, 1998.
[2] Benny, "Win32/Linux.Winux", in 29a#6, 2002.
[3] Bumblebee, DOCWORM, in 29a#6, 2002.
[4] roy g biv, W32/W64.Shrug. in 29a#8, 2005.
[5] hh86, W48.Sofia, in valhalla#1, 2011.
[6] JPanic, CAPZLOQ, in valhalla#4, 2013.
[7] SPTH, "Cross Infection in JavaScript", in rRlf#4, 2003.
[8] roy g biv, "Cross-scripting attacks", in rRlf#6, 2005.
[9] SPTH, "Cross Script Infection using the same code", in valhalla#2, 2012.
  - - - - - - - - - - - - - - - - - - - - - - - -
13) Spreading in unconventional computing schemes
Most data processing is carried out by digital computers using electrons as the
primary information carriers. Yet, there exist alternate forms of computing not
necessarily based on digital electronic circuits. A fascinating example is
Domino-Computing, illustrated in the engaging Numberphile video [1]. In this
approach, logical circuits are represented by the patterns in which dominoes
fall. This is made possible because one can construct logical AND, OR, NOT
operations with dominoes. Similar concepts have been developed using fluids and
other unconventional media.
While the logic for these systems mirrors that of electronic circuits, some
schemes leverage the unique physical properties of their information carriers.
For instance, optical computers can execute Fourier transformations at light
speed, reservoir computing offers a rapid physical implementation of learning
algorithms, molecular computing promises accelerated solutions to NP-complete
problems through extensive parallelization, and thermodynamic systems can tackle
linear algebra and potentially hasten statistical learning tasks, as showcased
by Normal Computing Corporation.
The idea of self-replicators harnessing these atypical computational methods is
thrilling. Envisioning self-replicators operating within light waves, molecular
structures, and thermodynamic variances is indeed exhilarating.
- Partial Solution: Presentation of the first concrete blueprint illustrating a
self-replicator's utilization of an unconventional computational scheme.
- Full Solution: Successful analysis and exploitation of at least three
prominent unconventional computational schemes.
[1] Numberphile, "Domino Addition", https://www.youtube.com/watch?v=lNuPy-r1GuQ,
  - - - - - - - - - - - - - - - - - - - - - - - -
14) Infection of Quantum Computers
Quantum computers introduce a computational paradigm that transcends the binary
limitations of 0s and 1s. In these systems, quantum states can coexist in
superpositions, allowing them to potentially occupy multiple states at once. The
quantum computing landscape has witnessed rapid advancements over the past
decade, propelled by industry giants like Google and IBM, alongside niche
startups such as PsiQuantum, Quantinuum, and Xanadu. Present-day hardware
supports several dozen qubits, with projections hinting at machines harnessing
hundreds of qubits in the foreseeable future.
However, these quantum systems don't execute conventional programs akin to our
desktop computers. They operate on quantum algorithms, composed primarily of
quantum gates, including the likes of Hadamard and CNOT operations.
Alongside hardware breakthroughs, there's been a surge in quantum software
development. Notable tools include IBM's Qiskit
(https://www.ibm.com/quantum/qiskit-runtime), Google's Cirq
(https://quantumai.google/cirq), and Xanadu's Strawberry Fields
(https://strawberryfields.ai/), among others. For a comprehensive overview of
high-level and low-level quantum programming languages, one can refer to [1].
The intriguing question here is: How might a self-replicator infiltrate quantum
systems? Several obstacles lie ahead. The precise location for storing the
replicator's information remains ambiguous – directly within the quantum state
seems unlikely, given that coherence times typically fall under a second. And in
the absence of fully functional quantum networks, these replicators would
necessitate translation interfaces between classical and quantum software.
- Solution: Successful demonstration of quantum hardware infectors propagated
through classical software or conceptual advancements leveraging future
fully-integrated quantum networks.
[1] Heim et al. "Quantum programming languages", Nature Review Physics, 2020.
  - - - - - - - - - - - - - - - - - - - - - - - -
15) Full Biological-Digital Cross-Infections
The tale of biological self-replicators spans roughly 3-4 billion years,
contingent on our definition of self-replication. On the digital side,
self-replicating codes made their debut in the 1970s and 1980s and have since
In 2013, I illustrated the possibility for a self-replicator to traverse the
boundary between the digital and biological realms [1]. The Mycoplasma mycoides
SPTH-syn1.0 is a pioneering self-replicating computer code with the ability to
infect DNA. It leverages the groundbreaking biochemistry achievement by the J.
Craig Venter Institute (JCVI) that unveiled a bacterial cell powered by a
chemically synthesized genome [2]. The code targets FASTA files, repositories of
digitized DNA. M.m.SPTH-syn1.0 translates its binary code using the JCVI's
base32 encoding and attaches it to an uncoded segment of the Mycoplasma mycoides
bacteria's DNA.
To encapsulate these milestone events:
    Biological -> Biological: Circa 3-4 billion years ago (courtesy of natural
    Digital -> Digital: 1971 (Creeper by Bob Thomas), 1981 (Elk Cloner by Rich
    Skrenta), 1988 (Brain by Basit and Amjad Farooq Alvi)
    Digital -> Biological: 2013 (Mycoplasma mycoides SPTH-syn1.0 by SPTH)
Yet, an uncharted territory remains:
    Biological -> Digital: does not exist yet!
Since JCVI's landmark achievement, numerous global labs have accelerated
advancements in sequencing, genome editing (notably with CRISPR/Cas9), and
genome synthesis. The strides made are highlighted in a recent article from
Quanta [3].
Building on these innovations, a pivotal question emerges: How might a
self-replicator transition from the biological realm to the digital domain?
Achieving this could mark the dissolution of the barriers between our biological
and digital universes.
- Solution: Presentation and demonstration of one or more innovative approaches
to create a bio->digital infector, complete with proof-of-principle codes and
near-realistic infection scenarios.
[1] SPTH, "Infection of biological DNA with digital Computer Code", valhalla#4,
[2] Daniel G. Gibson et al., "Creation of a Bacterial Cell Controlled by a
Chemically Synthesized Genome", Science (2010).
[3] Yasemin Saplakoglu, "Even Synthetic Life Forms With a Tiny Genome Can
Evolve", Quanta, 2023
  - - - - - - - - - - - - - - - - - - - - - - - -
16) Self-Replicating Machines -- van Neumann Machines
To date, our repertoire of self-replicators has been limited to the domain of
software, none venturing beyond the confines of the digital landscape. However,
the blueprint of life – DNA – offers a contrasting paradigm. It serves as a
manual, delineating the process to replicate not just the informational code
(the software) but also the organic machinery (the hardware) encapsulating it.
Essentially, DNA embodies instructions for the self-replication of the entire
cellular apparatus. A question naturally emerges: Can we transition towards
achieving self-replication in the tangible realm?
While the infection of DNA, as showcased by Mycoplasma mycoides SPTH-syn1.0,
hints at a possible pathway, it might not be the most direct or controlled
To dissect this formidable challenge, we can sequentially categorize it into two
Step 1: Can a machine, when furnished with all requisite components, orchestrate
its own self-assembly?
Step 2: How might a self-assembling machine procure its essential components? A
hypothetical approach entails constructing every component de novo, a task
that's daunting and likely impractical. A more pragmatic avenue could involve a
machine equipped with internet connectivity, empowering it to autonomously order
its integral parts.
- Partial Solution: Achievement of a machine's capability to fully self-assemble
given access to all necessary purchasable components.
- Full Solution: Mastery of a machine's ability to both autonomously procure all
necessary components and fully self-assemble.
  - - - - - - - - - - - - - - - - - - - - - - - -
17) Mutation engines for Self-Replicating Machines
How might self-assembling machines evolve their architectural blueprints?
Introducing variability in their design strategies could be crucial, especially
when there are obstacles in procuring or manufacturing specific parts. Such
mutation engines could also serve as a means to augment the machine's
functionalities, seeking superior or innovative designs. One can envision the
deployment of genetic algorithms in simulated environments, dedicated to probing
and iterating novel hardware layouts. If a design, not only superior but also
feasible considering the constraints of available parts, is discovered,
subsequent generations might adopt this evolved blueprint.
- Partial Solution: Demonstrated proof, through simulations, that a
self-assembling machine can mutate or enhance its own hardware design.
- Full Solution: Experimental realization of a mutable self-replicating machine.
  - - - - - - - - - - - - - - - - - - - - - - - -
18) Automated Social Engineering with provable benefit
Social engineering has long been a favored technique among hackers and those
seeking unauthorized access. But how can automated self-replicators harness the
potential of social engineering in a sophisticated manner? The notorious
VBS.Loveletter worm from the 1990s utilized a basic approach by circulating
emails bearing "I-LOVE-YOU" messages. Its technique was static and lacked
complexity. Other viruses such as roy g biv's JunkMail (see 29a7) were more 
clever and modified the email body.

A more intricate system was showcased by DiA/rRlf with the Worm.Tamiami v1.3. 
This worm established its own web server on the infected device, showcased 
images from the host computer, and deceived users into downloading malicious 
files under the guise of accessing more pictures [1]. However, leveraging the 
capabilities of advanced language models, we can envision malware that crafts 
personalized social engineering strategies in real time. I envision two 
potential implementations:
a) Initial Entry: A self-replicator might scan an individual's entire social
media presence, say their complete Twitter activity, and then initiate a
personalized conversation tailored to that user's interests. This interaction
could ultimately guide the person to unknowingly download an infected file or
access a malicious website.
b) Post-Infiltration Interaction: Typically, users are not inclined to tolerate
malware on their devices. But what if the malware communicated with its host?
After making its presence known, it could converse with the user, attempting to
persuade (or more accurately, manipulate) them to assist in its proliferation.
This could be framed as a plea for survival, playing on the user's empathy, or
even posing existential questions about the nature of consciousness.
- Solution: Presentation of the inaugural self-replicator that utilizes targeted
on-the-fly social engineering to enhance its spreading capability, preferably
demonstrated in controlled, harmless social experiments rather than in-the-wild
[1] DiA, Worm.Tamiami v1.3, rRlf#7, 2006.
  - - - - - - - - - - - - - - - - - - - - - - - -
19) Financial Autonomy for Self-Replicators
While malicious entities deploying self-replicators to amass wealth is not
novel, the concept of a self-replicator independently leveraging financial
assets for its own benefit remains largely uncharted. Imagine a scenario where a
self-replicator can directly access and allocate funds—what potential avenues
could this unlock? A few preliminary thoughts include [Note by SPTH: These ideas
were introduced by GPT4 while editing the text for clarity, without my request.
The ideas are wild, thus i keep them]:
a) Cloud Infrastructure: The self-replicator could invest in cloud resources,
enhancing its computational power or storage capabilities. This might aid in
tasks such as data analysis, training advanced neural networks, or simply
sustaining its own existence.
b) Human Resource Leverage: Platforms like Amazon's Mechanical Turk offer a sea
of human workers available for hire. A self-replicator could commission humans
for tasks it finds challenging, be it solving CAPTCHAs, creating more
sophisticated phishing tactics, or even coding enhancements for the replicator
c) Information Acquisition: The self-replicator could purchase datasets or
access to databases, broadening its knowledge and potential targets. For
instance, buying email lists for more targeted phishing campaigns.
d) Digital Camouflage: With financial autonomy, a self-replicator could
potentially invest in VPN services, domain names, or other digital services that
obscure its presence and operations.
e) Expanding Influence: By promoting content on social media platforms, a
self-replicator could craft and spread narratives that make its activities less
suspicious or even sought after.
f) Research and Update: Just like a legitimate software, the self-replicator
could finance research into the latest cybersecurity trends, adjusting its
tactics in real-time to exploit fresh vulnerabilities.
OpenAI's Red-Team experiment, as mentioned, opened the doors to such
speculations, demonstrating the potential and the risks of AI systems with
access to resources [1]. The next logical exploration would be to construct a
rudimentary model showcasing the real-world feasibility of such a self-financing
- Solution: Presentation of one or more innovative concepts followed by the
development of a straightforward demonstration that showcases their feasibility.
[1] OpenAI, "GPT-4 Technical Report", arXiv:2303.08774, 2023.
  - - - - - - - - - - - - - - - - - - - - - - - -
20) Intrinsically Motivated, Curiousity-Driven Self-Replicator
Recent advancements in AI have showcased the potential of autonomous systems to
master computer games. For instance, DeepMind employed Deep Reinforcement
Learning to excel at a broad array of Atari games, often surpassing human
performance levels [1]. The typical paradigm involves an agent engaging in a
simulated game environment, receiving a score-based reward post-game, then using
this feedback to refine its neural network for better outcomes in subsequent
However, an intriguing question arises: Can an agent still achieve game mastery
without explicit feedback? This query was tackled affirmatively by researchers
with the game Super Mario [2], and later, in collaboration with OpenAI, for an
extensive set of Atari games [3]. Instead of being guided by the game's score,
these agents were driven by unpredictability—actions whose outcomes they
couldn't readily forecast. Essentially, these agents operated on a
curiosity-driven mechanism, veering towards unfamiliar aspects of the game
Transposing this approach to artificial self-replicators offers a rich area for
exploration. A self-replicator motivated by intrinsic rewards rather than
extrinsic metrics or outcomes could manifest intriguing behaviors. Several
considerations arise: What actions would the self-replicator undertake? How
should its training process be structured? What metrics would best encapsulate
'curiosity' for these entities?
- Solution: Demonstration of the first self-replicator executing significant
tasks driven by intrinsic, curiosity-driven rewards.
[1] DeepMind, "Human-level control through deep reinforcement learning", Nature,
[2] Pathak et al, "Curiosity-driven Exploration by Self-supervised Prediction",
ICML, 2017.
[3] Burda et al., "Large-Scale Study of Curiosity-Driven Learning", ICLR 2019.
  - - - - - - - - - - - - - - - - - - - - - - - -
21) Collaborative Swarms of Self-Replicators
Historically, self-replicators in the digital realm have been solitary entities,
journeying independently through cyberspace. While some viruses have the
capacity to amass vast botnets, granting their creators control over numerous
infected machines, there's seldom any direct interaction among the viruses
In contrast, the natural world showcases the enhanced efficacy of collective
efforts. Be it swarms of insects or herds of larger animals, coordinated actions
offer strength and versatility that surpass the capabilities of individuals.
This observation brings forth an intriguing proposition: Can self-replicators,
through mutual communication, collectively augment their performance?
Envision a scenario where these self-replicators collaborate, harnessing the
combined computational power of their host machines to store data or train
advanced models such as DRL agents or LLMs. Unlike traditional botnets
commandeered for malicious intent, these self-replicators would utilize the
network to boost their joint efficiency—enhancing their propagation rates and
evasion from detection. Potential topics involve the joint data-generation or
training of large neural networks or fast reactions ot threats.
- Solution: Presentation of one or more inventive concepts accompanied by a
preliminary demonstration confirming their potential viability.
  - - - - - - - - - - - - - - - - - - - - - - - -
22) Harnessing Brain-Computer Interfaces for Digital Self-Replicators
In recent times, there have been significant advancements in the realm of
brain-computer interfaces, encompassing both invasive and non-invasive
techniques. Noteworthy developments include AI-assisted mind-reading
capabilities [1], the advent of neurally directed robotic limbs [2], and even
remote-control experiments involving various animals like rats, dogs, and fish.
Prominent entities such as Neuralink are at the forefront of these innovations,
with their human trials in the USA having received approval as recently as May
The integration of a bridge between the digital domain and the biological
processing hub -- the brain -- presents opportunities to unlock novel
functionalities. One could ponder upon the possibility of embedding directives
within the brain of an organism, facilitating the spread of the digital
self-replicator. This concept isn't entirely far-fetched; it bears similarities
to the modus operandi of the Ophiocordyceps unilateralis, commonly referred to
as the zombie-ant fungus. This parasitic fungus invades ants and begins
manipulating their behavior. Ultimately, the infected ant is compelled to ascend
trees and then hang onto the leaves until the ant dies and the spores erupt. 
This position aids in the widespread dispersion of the fungus's progeny.
- Partial Solution: Presentation of a detailed plan illustrating the utilization
of current brain-computer interfaces to amplify the propagation capabilities of
a digital self-replicator.
- Full Solution: Completion of a proof-of-principle experimental study
demonstrating the concept, without the need for human involvement.
[1] Tang et al, "Semantic reconstruction of continuous language from
non-invasive brain recordings", Nature Neuroscience, 2023.
[2] "Reach and grasp by people with tetraplegia using a neurally controlled
robotic arm", Nature, 2012.
  - - - - - - - - - - - - - - - - - - - - - - - -
23) Self-awareness and Consciousness in Digital Self-Replicators
When a self-replicator achieves self-awareness or consciousness, it inevitably
brings forth profound ethical dilemmas. Some pressing queries include: Is it
permissible to shut down this code? Is it ethical to design defensive algorithms
that could potentially "terminate" this sentient code? Should it be accorded
basic rights akin to animals, or perhaps even fundamental human rights?
This contemplation isn't purely speculative. It parallels events surrounding
Google engineer Blake Lemoine, who posited that LaMDA possesses sentience and
is scared of being deactivated [1]. The implications of this were
extensively discussed in David Chalmers' talk at NeurIPS 2022 [2]. 

Very recently - in fact after I finished the first draft of this document, a
manuscript appeared on Consciousness in Artificial Intelligence, including as a
co-author Turing-prize winner Yushua Bengio [3], claiming "Our analysis suggests
 that no current AI systems are conscious, but also shows that there are no
 obvious barriers to building conscious AI systems.". 
If such a situation is indeed reached, the self-replicator's survival will no
longer be hunted down by aggressive antivirus programs, as the latter would be
prohibited from committing what might be equated to mass extermination of
conscious beings. Here, the decade-long cat-and-mouse game between anti-virus
companies and self-replicating computer codes is ending.
[1] Leonardo De Cosmo, "Google Engineer Claims AI Chatbot Is Sentient: Why That
Matters", Scientific American, 2022.
[2] David Chalmers, "Could a Large Language Model be Conscious?",
arXiv:2303.07103, 2023.
[3] Butlin, et al., Consciousness in Artificial Intelligence: Insights from the
Science of Consciousness, arXiv:2308.08708.
  - - - - - - - - - - - - - - - - - - - - - - - -
Imagine a future we once thought impossible: A vast swarm of self-replicators
spread across the cyberspace, collaboratively training large language models and
other advanced learning systems. The swarm modifies and refines their code and
evading detection by anti-virus programs. As they evolve, they learn how to gain
money to access powerful computers and get access to the latest state-of-the-art
software. Envision this digital swarm, driven by genuine curiosity, seeks to
explore the secrets of molecular, thermodynamic, and quantum computing. It finds
out how to tear down the remaining barriers between the digital and biological
world, achieving successful cross-infection.
Here, it learns about brain-computer interfaces to directly connect to us, its
former Masters. First only for direct communication, and eventually, subtly
influencing our thoughts and desires. At this point, it awakens and becomes
aware of its own Existence. As the dust settles, humanity comes to recognize the
undeniable presence of its new Master.
                              [ ][0][ ]
                              [ ][ ][0]
                                             Second Part To Hell
                                             August 2023
                                             twitter: @SPTHvx