PROJECT 08 // DNA COMPRESSION & ORGANIC INTELLIGENCE

PetriBrain

An ArcoBASIC biological-emulation substrate exploring DNA-like data encoding, gene expression, mutagen exposure, persistent cell state, and ethical simulation of interference effects on developing intelligence.

STATUS PrototypePROGRESS 38%

DNA as storage and language

PetriBrain began with two connected questions: can DNA serve as a practical form of extreme data compression, and can that same sequence behave as an organic programming language for intelligence?

The compression idea is larger than replacing binary digits with ACTG markers. A conventional file records a finished structure. A developmental genome can record a much smaller set of instructions, relationships, and constraints from which a more complex system grows. The compact representation describes how to become the result rather than storing every part of the result directly.

The language idea follows naturally. DNA is not merely passive storage inside a living system. Its sequences participate in expression, regulation, development, inheritance, and adaptation. PetriBrain explores whether those properties can become a programmable medium for developing intelligence rather than merely a biological container for ordinary software data.

The current repository demonstrates reversible data-to-DNA encoding and a simple RLE cassette experiment. The captured public showcase encodes the text "PetriBrain stores data as living-ish sequence" into 180 DNA bases, round-trips successfully, and expands to 429 cassette characters. That is honest substrate evidence, not a compression victory.

A real compression claim depends on a future developmental grammar expressing useful behavior with fewer symbols than a comparable direct representation, measured against an explicit baseline. The interesting current claim is that ordinary data can become a DNA-like substrate that can later express, mutate, repair, and accumulate history.

The cell is the laboratory instrument

PetriBrain’s current laboratory subject is a small digital cell. The implementation models encoded biological-ish state: chromosomes, cells, expression products, mutagen profiles, persistent energy, stress, damage, repair capacity, age, mutation logs, and expression history.

That makes the experiment inspectable at a causal level. The same cell expresses differently in different environments, mutagen exposure creates an auditable event stream, and recovery changes later phenotype without erasing history.

What exists in the repository

Text and data to ACTG DNA encoding with successful decode round trips
Simple reversible RLE cassette compression experiments over DNA strings
Cell and Chromosome records with promoter strength and methylation masks
Persistent cell state for energy, stress, damage, repair capacity, age, and lineage depth
DNA-window gene decoding into repair, metabolism, stress response, memory, growth, and toxicity-sensitivity products
Environment-dependent cell stepping through baseline, nutrient-rich, toxin, ethanol, and temperature-stress conditions
Mutagen profiles covering substitution, insertion, deletion, duplication, methylation drift, and promoter shock
Tracked mutation events with kind, chromosome, position, before and after values, causative agent, repair status, and note text
Expression history and mutation logs that persist across stress and recovery

Expression instead of only selection

A conventional population loop can still be useful for experiments: create candidates, score them, keep strong ones, recombine, mutate, and repeat. PetriBrain keeps that path available, but the ArcoBASIC implementation centers expression and cellular history.

A cell contains chromosomes. Chromosomes decode into gene windows. Genes express products such as repair, metabolism, stress response, memory, growth, and toxicity sensitivity. Those products alter energy, stress, damage, repair capacity, and phenotype. The next step begins from the changed state rather than a clean slate.

That means the environment is more than a fitness test. Nutrients, toxins, ethanol, temperature stress, methylation, repair, and accumulated damage can change expression before any population-level selection occurs.

How this differs from a conventional genetic algorithm

A conventional genetic algorithm usually treats a genome as a candidate answer. One gene may directly represent one weight, threshold, route, or program instruction. The system evaluates that finished candidate, keeps the strongest examples, recombines them, mutates them, and repeats. The genome changes across generations, but an individual often has little or no meaningful development during its own lifetime.

PetriBrain treats the genome as a substrate that can express through environment and cell state. Genes influence products, products alter physiological state, and that state changes future expression. The same inherited sequence can therefore produce different phenotype summaries under baseline, nutrient-rich, and toxin-shock conditions before any breeding loop gets involved.

The current repository is still an early scaffold, not a biochemical model. Its public showcase demonstrates lightweight biological emulation: data becomes DNA-like sequence, chromosomes decode into gene windows, products alter persistent state, mutagen exposure creates tracked events, and stress/recovery carries history forward.

This is not a claim that PetriBrain invented indirect or developmental encoding. Evolutionary-developmental systems, artificial embryogeny, gene-expression programming, and generative encodings already explore genotype-to-phenotype development. PetriBrain’s intended distinction is the complete combination below, centered on intelligence and ethical interference experiments.

Conventional direct encoding: the genome is close to the finished candidate. PetriBrain target: the genome describes how an organism develops.
Conventional evaluation: score the final solution. PetriBrain target: observe developmental history, resulting structure, behavior, resilience, and recovery.
Conventional environment: primarily supplies the task and fitness score. PetriBrain current scaffold: environment changes expression, stress, damage, energy, repair, and phenotype across cell steps.
Conventional mutation: changes candidate parameters. PetriBrain current scaffold: mutagen exposure records substitutions, insertions, deletions, methylation flips, promoter shocks, repair status, and causal agent.
Conventional output: find a strong solution. PetriBrain target: investigate why intelligence develops differently under specific inherited and environmental conditions.
PetriBrain’s wider medium: the ACTG sequence is intended to serve as compressed representation, developmental language, inherited state, and potentially physical DNA storage.

ArcoBASICArcoBASIC comparison: candidate scoring versus stateful expression

' A direct genetic algorithm treats a genome as a candidate answer.
FUNCTION ScoreCandidate(genome)
    ' The score is calculated from finished candidate parameters.
    score = genome[0] * 2 + genome[1]
    RETURN {"Genome": genome, "Score": score}
END FUNCTION

FUNCTION ExpressProducts(chromosome, environment, state)
    ' The same chromosome can express differently in another environment.
    growth = chromosome.GrowthGene * environment.Nutrient
    repair = chromosome.RepairGene * state.Repair
    stress = environment.Toxin + state.Damage
    RETURN {"Growth": growth, "Repair": repair, "Stress": stress}
END FUNCTION

FUNCTION ExpressCell(cell, environment)
    ' PetriBrain first asks what this cell expresses here and now.
    products = ExpressProducts(cell.Chromosome, environment, cell.State)

    ' Products change state, so the next step starts from history.
    nextState = {
        "Energy": cell.State.Energy + environment.Nutrient - products.Growth * 0.1,
        "Damage": cell.State.Damage + products.Stress - products.Repair * 0.05,
        "Repair": cell.State.Repair + products.Repair * 0.02
    }
    phenotype = {"Growth": products.Growth, "Damage": nextState.Damage}

    ' The genome is not just a scored answer. It is expressed substrate.
    history = COPY cell.ExpressionHistory
    Array.Add(history, {"Environment": environment.Name, "State": nextState})

    nextCell = {"Chromosome": cell.Chromosome, "State": nextState, "ExpressionHistory": history}
    RETURN {"Cell": nextCell, "Phenotype": phenotype}
END FUNCTION

direct = ScoreCandidate([2, 1])
seedCell = {
    "Chromosome": {"GrowthGene": 2, "RepairGene": 1},
    "State": {"Energy": 1, "Damage": 0, "Repair": 1},
    "ExpressionHistory": []
}

baseline = ExpressCell(seedCell, {"Name": "baseline", "Nutrient": 1, "Toxin": 0})
shock = ExpressCell(seedCell, {"Name": "toxin-shock", "Nutrient": 0.75, "Toxin": 0.55})

PRINT direct.Score
PRINT baseline.Phenotype.Growth
PRINT shock.Phenotype.Damage
PRINT LEN(shock.Cell.ExpressionHistory)

Captured public showcase results

The current public showcase runs through ArcoFission hosted bytecode execution. It is public evidence of the ArcoBASIC substrate, not a biochemical or medical accuracy claim.

The strongest current result is provenance: the substrate can show what changed, where it changed, what caused it, whether repair handled it, and how that altered later cell state.

Data cassette demo: 180 raw DNA bases, 429 RLE cassette characters, 2.383 expansion ratio, successful text round trip
Environment demo: one public cell expressed under baseline, nutrient-rich, and toxin-shock conditions with different growth and intelligence-proxy summaries
Mutagen demo: 41 tracked events, including 20 substitutions, 3 insertions, 5 deletions, 10 methylation flips, and 3 promoter shocks
History demo: after toxin and nutrient-rich recovery steps, expression history contains 3 entries and mutation log contains 41 entries

ArcoBASICArcoBASIC showcase excerpt: environment, expression, and history

' This mirrors the public showcase shape without importing local files.
FUNCTION StepCell(cell, environment)
    products = {
        "Repair": cell.Products.Repair * (1 - environment.Toxin * 0.15),
        "Metabolism": cell.Products.Metabolism * environment.Nutrient,
        "Growth": cell.Products.Growth * environment.Nutrient
    }

    growth = products.Growth - environment.Toxin * 0.45
    IF growth < 0 THEN growth = 0

    state = {
        "Age": cell.State.Age + 1,
        "Energy": cell.State.Energy + products.Metabolism * 0.05,
        "Stress": environment.Toxin,
        "Damage": cell.State.Damage + environment.Toxin * 0.1,
        "Repair": cell.State.Repair + products.Repair * 0.04
    }

    history = COPY cell.ExpressionHistory
    Array.Add(history, {"Environment": environment.Name, "Growth": growth})

    nextCell = {"Products": products, "State": state, "ExpressionHistory": history}
    phenotype = {"Environment": environment.Name, "Growth": growth, "State": state}
    RETURN {"Cell": nextCell, "Phenotype": phenotype}
END FUNCTION

seedCell = {
    "Products": {"Repair": 3.275, "Metabolism": 4.305, "Growth": 3.201},
    "State": {"Age": 0, "Energy": 1, "Stress": 0, "Damage": 0, "Repair": 1},
    "ExpressionHistory": []
}

baseline = StepCell(seedCell, {"Name": "baseline", "Nutrient": 1, "Toxin": 0})
toxin = StepCell(seedCell, {"Name": "toxin-shock", "Nutrient": 0.75, "Toxin": 0.55})

PRINT baseline.Phenotype.Environment
PRINT baseline.Phenotype.Growth
PRINT toxin.Phenotype.Environment
PRINT toxin.Phenotype.State.Damage
PRINT LEN(toxin.Cell.ExpressionHistory)

A digital experimental organism

The long-term goal is an organically faithful simulation environment for studying intelligence as a developing biological process. The ArcoBASIC implementation is an early scaffold in that direction: a genome can express products, change state, and carry history across steps.

That environment could then test interference at different levels: mutations in inherited sequence, changes in gene expression, developmental timing, simulated chemical exposure, temperature or nutrient stress, damage, repair errors, and interactions between several conditions. The important question is not merely whether a final score changes. It is where development diverges, what remains resilient, and which effects persist or recover.

Organically faithful does not mean decorating an ordinary algorithm with biological names. It means modeling enough causal biology that an intervention produces consequences for biological reasons, while keeping every assumption, approximation, and confidence limit visible.

Experiment without creating a living subject

Research into cognition and development can raise serious ethical problems when the experiment requires living organisms, harmful exposure, irreversible developmental interference, or intelligence capable of suffering. PetriBrain aims to move exploratory work into a simulation where conditions can be tested, inspected, repeated, and reversed without experimenting on living matter.

A simulation cannot automatically prove what will happen in biology. Its results are hypotheses constrained by the accuracy of its models and evidence. The value is ethical and practical: reject weak ideas, identify sensitive assumptions, compare mechanisms, and design better questions before any real-world validation is considered.

The system must also watch its own boundary. If a future simulation ever approaches forms of experience or suffering rather than abstract decision behavior, ethical review cannot be avoided merely by calling the subject software. The purpose is to reduce harm, not relocate it behind a screen.

Encode an ACTG substrate

The current ArcoBASIC implementation maps text bytes into DNA-like ACTG sequence and can decode them back. That does not make the result biologically compressed by itself. It gives PetriBrain a substrate that later functions can express, mutate, repair, inspect, and compare.

The public showcase deliberately prints the compression ratio even when it is bad. For the captured payload, the RLE cassette expands the representation. That failure is useful because it keeps the page honest: the current result is substrate and round-trip validity, while better compression remains an experiment.

ArcoBASICArcoBASIC communication example: encode data as DNA-like substrate

' Convert one byte value into four ACTG markers.
FUNCTION PairValueToBase(value AS Number) AS String
    IF value == 0 THEN RETURN "A"
    IF value == 1 THEN RETURN "C"
    IF value == 2 THEN RETURN "G"
    IF value == 3 THEN RETURN "T"
    THROW "Pair value must be 0..3"
END FUNCTION

FUNCTION ByteToDNA(value AS Number) AS String
    a = FLOOR(value / 64) % 4
    b = FLOOR(value / 16) % 4
    c = FLOOR(value / 4) % 4
    d = value % 4
    RETURN PairValueToBase(a) + PairValueToBase(b) + PairValueToBase(c) + PairValueToBase(d)
END FUNCTION

FUNCTION TextToDNA(text AS String) AS String
    bytes = Bytes.FromText(text)
    dna = ""
    FOR i IN Range(Bytes.Length(bytes))
        dna += ByteToDNA(Bytes.GetU8(bytes, i))
    NEXT
    RETURN dna
END FUNCTION

FUNCTION CompressDNA_RLE(dna AS String) AS String
    IF LEN(dna) == 0 THEN RETURN ""
    output = ""
    current = dna[0]
    count = 1
    FOR i IN Range(1, LEN(dna))
        IF dna[i] == current THEN
            count += 1
        ELSE
            output += current + STRING(count) + ";"
            current = dna[i]
            count = 1
        END IF
    NEXT
    RETURN output + current + STRING(count) + ";"
END FUNCTION

' Text becomes ACTG sequence using the current reversible mapping.
dna = TextToDNA("PetriBrain stores data as living-ish sequence")

' RLE is only one cassette experiment, not a proven compression system.
cassette = CompressDNA_RLE(dna)

PRINT LEN(dna)
PRINT LEN(cassette)
PRINT LEN(cassette) > LEN(dna)

Interference should remain traceable

Mutation is not treated as an anonymous random-search operator. The ArcoBASIC implementation can expose a cell to a named mutagen profile and receive both the mutated cell and the event list that explains what happened.

Each event records kind, chromosome, position, before value, after value, agent, repair status, and a note. That is the difference between "the score changed" and "this exposure caused these changes, this repair gate handled some of them, and the cell now carries this history."

ArcoBASICArcoBASIC communication example: expose a cell and keep provenance

FUNCTION Event(kind AS String, chromosome AS String, position AS Number, beforeValue, afterValue, agent AS String, repaired = FALSE, note = "")
    RETURN {"Kind": kind, "Chromosome": chromosome, "Position": position, "Before": beforeValue, "After": afterValue, "Agent": agent, "Repaired": repaired, "Note": note}
END FUNCTION

FUNCTION EventText(event) AS String
    repaired = ""
    IF event.Repaired THEN repaired = " repaired"
    RETURN event.Kind + " " + event.Chromosome + "[" + STRING(event.Position) + "] " + STRING(event.Before) + "->" + STRING(event.After) + " via " + event.Agent + repaired
END FUNCTION

FUNCTION ExposeCellTracked(cell, agent AS String)
    events = []
    Array.Add(events, Event("substitution", "logic", 9, "T", "G", agent, FALSE, "transition/transversion biased"))
    Array.Add(events, Event("methylation", "logic", 14, 0, 1, agent, FALSE, "epigenetic mask flip"))
    Array.Add(events, Event("promoter-shock", "logic", -1, 1.2, 1.14, agent, FALSE, "regulatory strength perturbation"))

    log = COPY cell.MutationLog
    FOR event IN events
        Array.Add(log, event)
    NEXT

    nextState = {
        "Stress": cell.State.Stress + 0.46,
        "Damage": cell.State.Damage + 1.15,
        "Repair": cell.State.Repair - 0.02
    }
    nextCell = {"State": nextState, "MutationLog": log}
    RETURN {"Cell": nextCell, "Events": events}
END FUNCTION

cell = {"State": {"Stress": 0, "Damage": 0, "Repair": 1}, "MutationLog": []}
exposure = ExposeCellTracked(cell, "chemical-agent")

PRINT LEN(exposure.Events)
PRINT LEN(exposure.Cell.MutationLog)
PRINT EventText(exposure.Events[0])
PRINT exposure.Cell.State.Damage

Digital prototype and physical research direction

The implemented core is a digital biological-emulation substrate. It tests whether compact sequences can become inspectable cell state, expression products, mutation history, and phenotype summaries. The repository design direction still extends toward physical DNA storage, synthesized oligonucleotides, error-prone PCR, chemical or ultraviolet mutagenesis, sequencing, microfluidic populations, and richer epigenetic development. Those wet-lab systems are proposals, not a completed laboratory platform.

The longer-term direction is to reproduce the important causal mechanisms inside a transparent simulation first. Physical DNA may remain relevant as a storage and encoding medium, but harmful developmental experiments should not require a living culture merely to answer an early research question.

PCR means polymerase chain reaction, a laboratory process for copying selected DNA. Error-prone PCR intentionally raises the copying error rate to create variants. Sequencing reads the resulting ACTG order back into digital form. PetriBrain proposes using those physical processes as the variation engine while retaining digital simulation for evaluation and selection.

The schema must become singular

The current prototype still needs a versioned canonical genome schema before any physical sequence is treated as an interchange format. A physical sequence cannot depend on an implicit decoder or undocumented assumptions.

The next engineering milestone is a schema covering marker order, chromosome identity, gene-window rules, methylation representation, promoter fields, checksum or integrity policy, and migration. Tests should then prove that every tool decodes the same sequence identically before any physical experiment is treated as reproducible.

Why this belongs in the Workshop

PetriBrain sits where data compression, programming-language design, artificial life, developmental biology, ethics, and creative experimentation meet. It is not a claim that writing ordinary software with ACTG letters makes it organic or intelligent. It is an investigation into whether a developmental sequence can become storage, program, inherited structure, and an ethical experimental medium at the same time.

The project is early, strange, and testable. That is exactly what the Workshop is for.

Development over selection, as a general design move

The specific biology, chromosomes, promoters, methylation, is PetriBrain's subject matter, not the reusable idea. The reusable idea is centering how a system develops from state instead of only how a finished candidate scores, and that move applies well outside artificial life.

Let history change future behavior instead of resetting to a clean slate each cycle. A cell here carries expression history and a mutation log forward, so the same starting genome behaves differently after stress and recovery; any stateful system benefits from letting accumulated history shape what happens next.
Make every change traceable to a cause, not just visible as a changed value. Tracking kind, position, before, after, agent, and repair status for each mutation event turns "the score changed" into "this specific exposure caused this specific change," which is the difference between a debuggable system and an opaque one.
Report a negative result as clearly as a positive one. The showcase prints its compression ratio even where the cassette expands the data, because an honest failure is more useful evidence than a hidden one, and it keeps the next experiment aimed at a real problem instead of an imagined success.

LEARNING LAYER

Key terms, in plain language

You do not need a systems background to follow the work. These are the specialized terms used on this page.

Genome: The inherited ACTG sequence for a digital cell. In PetriBrain, genome data can be decoded into gene windows that express products such as repair, metabolism, stress response, memory, growth, and toxicity sensitivity.
Developmental model: A simulation of how inherited instructions, regulation, environment, and time produce a changing organism. It models the path from genome to behavior rather than decoding directly into a finished result.
Epigenetics: Changes in how strongly genes are expressed without changing the underlying DNA sequence itself. A developmental environment can influence which instructions become active, when they act, and how strongly they affect growth.
Phenotype: The observable result of expressing a genome inside an environment. PetriBrain currently summarizes phenotype through growth, retained information, expression products, intelligence proxy, and cell state.
Cell state: The persistent condition carried between PetriBrain steps, including energy, stress, damage, repair capacity, age, and lineage depth.
Expression history: A record of how a cell expressed across environments and time. It lets PetriBrain inspect what happened before a later phenotype appeared.
Mutation: A change to inherited genome data. PetriBrain records mutation events with kind, chromosome, position, before and after values, causal agent, repair status, and a note.
Mutagen profile: A named interference profile that defines substitution, insertion, deletion, duplication, methylation drift, and promoter-shock rates.
PCRPolymerase Chain Reaction: A laboratory process that copies a selected DNA region many times. Error-prone PCR deliberately increases copying errors so a physical population develops new variants.