Slides

Section 1: Abstract

Trees are an extremely old technology — the design hasn’t meaningfully changed in over 10 million years, yet a premium tree still takes 20 years to grow and wood remains expensive. The deeper question behind “how do we grow trees 100× faster?” is the problem of morphology: how does a single seed, running purely local computation in each cell, self-assemble into a global 3D form? We can design a bridge in CAD, but we have no equivalent for designing an organism — no way to translate a target 3D shape into the per-cell program that grows it. This project takes an engineering-first approach: build the missing CAD-for-cells layer in silico first, then map it onto biological substrates. As validation, I built Morpheus, a voxel-based cell morphology simulator in which each cell runs the same short program, communicates only with neighbours via diffusing hormone gradients, and collectively grows a cylinder (a “cigar”) from a single seed cell. The longer-term aim is to compile these designs onto a real chassis — the JCVI-syn3.0 minimal cell — and use the same primitives to grow custom organoids, faster trees, and eventually plants engineered into specific 3D shapes such as a house frame or a portable dwelling-seed for space travel.

Section 2: Project Aims

Section 3: Background

Literature Context

Two works frame the project. Beal, Lu & Weiss (2011), “Automatic Compilation from High-Level Biologically-Oriented Programming Language to Genetic Regulatory Networks” — establishes that high-level descriptions of cellular behaviour can, in principle, be compiled into concrete GRN constructs, and surveys the GRN motifs (toggles, repressilators, feed-forward loops, AND/OR/NOT gates) that earlier synthetic-biology landmarks built from real cells: Gardner, Cantor & Collins (2000) on the genetic toggle switch; Elowitz & Leibler (2000) on the repressilator; Atkinson et al. (2003) on rationally designed circuits; Alon (2003) on network motifs; and François & Hakim (2004) on morphogen-gradient compartmentation. Trewavas (2014), “Plant Behavior and Intelligence” / the physics-and-computation literature on plants — frames plant tropism as sensing → processing → actuating, where a plant performs spatial integration via distributed sensing and acts via directional growth. Both lines support the project’s central claim: that the tools and motifs to encode local cell programs already exist, but the compiler from desired 3D form down to per-cell code does not.

Innovation

The novel contribution is treating morphology as a programming problem and shipping a working in silico substrate for it. Rather than studying one organism’s developmental biology, Morpheus is a general voxel-based runtime where every cell runs the same program against local state and hormone gradients — closer to a CAD tool than a biology paper. The shape-decomposition approach (point → circle → cylinder, built from inheritable local state, emit/read gradients, and programmed cell death as scaffolding) is a concrete proposal for a primitive set in this design language. Combined with the observation that LLMs are now intelligent enough to discover the per-cell code given a target shape and a set of primitives, this reframes morphology from a biology-first problem into an engineering-first one.

Significance

Wood is expensive, but that’s the surface. Beneath it: we have no science for designing organisms, organoids, or cell-grown materials, and no theory of how the genome encodes 3D form. Every existing engineering discipline rests on divide-and-conquer — break the design into glued-together sub-parts — and biology stubbornly does not work that way: every cell runs the same program, all communication is local, and global structure is emergent. Cracking that gap would matter far beyond trees: it underlies how genotype maps to phenotype, why simulating tissue is currently intractable (one week of compute simulates ten minutes of a single JCVI-syn3.0 cell), and why drug design still requires human and animal trials instead of in-silico verification. A working theory unlocks faster trees, drug-bearing plants, cell-grown structures with no glue or joints, and self-assembling factories light enough for space travel.

Ethical Considerations

The capacity to design organisms with engineered 3D form raises clear dual-use concerns: non-maleficence (engineered organisms must not become invasive or disrupt ecosystems), beneficence (the technology should expand access — cheaper wood, cheaper medicine — rather than concentrate it), justice (benefits like grown-housing or grown-medicine must reach beyond well-resourced labs), and responsibility (designers are accountable for downstream effects of self-replicating, self-assembling systems they release).

Concretely: the project stays in silico through Aim 1, with no environmental release. Any in vivo work in Aim 2 uses contained chassis (JCVI-syn3.0 is intentionally fragile and unable to survive outside lab media) and follows standard BSL-1/2 containment. Unintended consequences considered include horizontal gene transfer, ecological escape of engineered plants, and the displacement risk to forestry-dependent economies if grown-on-demand wood matures faster than transition policy. Mitigations include kill-switches in any chassis, restricting in vivo work to non-reproducing cell-free or auxotrophic strains, and publishing the simulator and design language openly so that scrutiny and dual-use review aren’t bottlenecked behind a single lab.

Section 4: Experimental Design

Detailed Experimental Plan

1. Define the target shape. Pick a minimal 3D form that exercises self-assembly (a vertical cylinder, the “cigar”). Week 1.
2. Decompose the shape into primitives. Cylinder = (a) seed point, (b) radial 2D circle of given radius, (c) extrusion along +z up to a target height. Week 1.
3. Specify the cell substrate. Voxel-based 3D grid; one cell per voxel; cells have local state, can divide into a free neighbour cell, can emit and read scalar hormone gradients, and can undergo programmed death. Week 1.
4. Build the simulator runtime (Morpheus). Python; deterministic per-tick update; gradient diffusion via a cheap PDE-like relaxation; render with a 3D viewer. Open-sourced at github.com/liamzebedee/morpheus. Weeks 2–3.
5. Implement primitive 1: seed → axis. Seed cell sets is_axis=True with axis_potential=1.0; while potential > threshold, replicate +z and pass axis_potential * DECAY to child. Yields a 1D vertical line. Week 3.
6. Implement primitive 2: axis → radial circle. Axis cells emit a radial hormone gradient g_radial; any cell sensing g_radial < RADIUS_THRESHOLD flips inside=True and replicates outward in ±x, ±y. Yields a 2D disc per slice. Week 3.
7. Compose into a cylinder. Run primitives 1 and 2 simultaneously; verify the result is a vertical cylinder of correct height and radius. Week 4.
8. Tune parameters. Sweep DECAY, STOP_THRESHOLD, RADIUS_THRESHOLD against target dimensions; record sensitivity. Week 4.
9. Stress test. Vary seed location, asynchronous update order, gradient noise; confirm shape is robust. Week 4.
10. Document the cell-program API. Lock down replicate_toward, emit_gradient, read_gradient, child_state, programmed death, inherited vs. read-only state. Week 5.
11. Catalogue tactics. Decompose into reusable patterns: clocks, oscillators, multi-scale staging, scaffold + cell-death “remove the formwork”. Week 5.
12. Map primitives onto biological constructs. For each runtime primitive, identify a real GRN equivalent: toggle (Gardner et al.), repressilator (Elowitz & Leibler), feed-forward loop (Alon), morphogen gradient (François & Hakim). Week 6.
13. Pick a chassis for in vivo Aim 2. JCVI-syn3.0 minimal cell as the base; E. coli as a pragmatic intermediate for early circuit testing. Week 6.
14. Design an in vivo 1D demo. Single-axis growth via a synthetic morphogen — diffusible peptide + receptor + AND-gate that triggers division along a polarity cue. Order parts via Twist; assemble with Gibson. Future.
15. Stage to 2D and 3D demos. Add a second orthogonal morphogen for radial growth; verify on solid media with fluorescent reporters at axis vs. radial cells; analyse via microscopy + image segmentation. Future.

Techniques Checklist

Technique Deep-Dive

Chassis selection — JCVI-syn3.0 minimal cell. This project deliberately uses the minimal cell as its Aim 2 chassis because it strips the substrate down to the irreducible machinery for life, leaving the synthetic GRN and morphogen circuits as the dominant behavioural signal. JCVI’s recently released full-cell simulation model is a complementary asset: it allows the same per-cell program to be tested in silico at full biochemical fidelity before any wet-lab run. The trade-off is compute cost — current JCVI-syn3.0 simulation is roughly six days of wall-clock per fifteen-minute biological cell cycle — which justifies Morpheus operating at the abstract voxel level for early design iteration and reserving JCVI-syn3.0 for later validation only.

Construct design via synthetic GRNs. The cell program is encoded as a gene-regulatory network using established motifs: a toggle switch (Gardner, Cantor, Collins 2000) to lock cell identity post-differentiation; a repressilator (Elowitz & Leibler 2000) as an internal clock for staged development; a feed-forward loop (Alon 2003) for noise-robust thresholding of morphogen concentration; and a morphogen + reaction-diffusion module (François & Hakim 2004) for the spatial gradients that encode position. Constructs are assembled in Benchling, ordered as gene fragments via Twist, joined by Gibson assembly, and verified by sequencing and fluorescent-reporter readout. This deep-dive matters because the leap from voxel-program to wet-lab is, mechanistically, exactly this translation: every Morpheus primitive must map onto one of these GRN motifs to be physically realizable.

Industry Partners

JCVI (minimal cell + simulation), Ginkgo Bioworks (autonomous lab for circuit iteration), Twist Bioscience (DNA fragment supply), Opentrons (liquid handling for parallel circuit assays).

Section 5: Results & Validation

Validation Approach

Aim 1 is validated by demonstrating, in silico, that a single seed cell running a short local-only program self-assembles into a target 3D shape (a cylinder). The deliverable is a working open-source simulator (github.com/liamzebedee/morpheus) and a reproducible run that grows the cylinder from one cell using only inheritable state and diffusing hormone gradients — no global coordinator and no per-cell knowledge of absolute position.

Protocol

1. Initialize an empty voxel grid with one seed cell at the origin; mark it is_seed=True.
2. Each tick, every live cell executes the same Python program:
   • On seed step: set is_axis=True, axis_potential=1.0.
   • If is_axis and +z neighbour empty and axis_potential > STOP_THRESHOLD: replicate_toward('+z', child_state={is_axis: True, axis_potential: axis_potential * DECAY}).
   • If is_axis: emit_gradient('g_radial', 1.0).
   • If read_gradient('g_radial') < RADIUS_THRESHOLD: inside = True.
   • If inside and not yet expanded: replicate_toward each empty neighbour in ±x and ±y; mark has_grown_radial = True.
3. Diffuse g_radial across the grid each tick (relaxation step).
4. Run until no further divisions occur.
5. Render the final voxel field; measure resulting cylinder height and radius; compare to target.

Techniques Used

The validation exercises several synthetic-biology techniques in their in silico equivalents. Gradient emission and reading correspond directly to morphogen design (François & Hakim 2004): a scalar field broadcast by a class of cells and decoded by neighbours via a concentration threshold. Inherited child state implements asymmetric division with locked identity, the runtime analogue of a GRN toggle switch (Gardner, Cantor & Collins 2000). The decay-step counter on axis_potential plays the role of an internal clock — a count-down equivalent to a damped repressilator (Elowitz & Leibler 2000). And the inside flag’s threshold-and-latch behaviour is a feed-forward loop (Alon 2003) that filters transient gradient noise into a stable commit-to-divide decision. Each of these has a known wet-lab realization, which is what makes the simulation a credible blueprint for Aim 2 rather than a toy.

Data & Analysis

The simulator successfully grows a vertical cylinder from a single seed cell. With DECAY=0.9, STOP_THRESHOLD=0.37, RADIUS_THRESHOLD=1.5, the resulting structure contains roughly 120 cells: an axial column rises along +z until the inherited axis_potential decays below threshold (yielding a height of ~10 voxels, consistent with log(0.37)/log(0.9) ≈ 9.4), and at each axial level the radial hormone gradient produces a disc of radius ~1.5 voxels. The shape is stable across asynchronous update orders and across small perturbations to gradient diffusion, confirming that the global form is a function of the local rules rather than an artefact of update ordering. This is a direct validation that programming a cell with only local information can produce a globally specified 3D shape — the central claim of the project.

Challenges

The biggest unexpected challenge was conceptual rather than technical: writing local-only code is genuinely uncomfortable for an engineer trained on divide-and-conquer, because you cannot reach for a global coordinator or per-cell coordinates. Several early prototypes silently smuggled global state in via shared counters; rewriting them under the discipline of “every cell runs the same program against only its own state and what it can read locally” was the actual work. A second challenge is scale: the cylinder demo is ~120 cells, but a real leaf is ~10⁹ cells and a JCVI-syn3.0 cell takes ~6 days to simulate per 15-minute biological cell cycle, so the in silico-to-in vivo compilation will need much faster surrogate models or hybrid abstractions. Mitigations include hierarchical abstractions (simulate at the voxel level for design, drop to JCVI-fidelity only for spot-checks), and using LLMs to discover candidate cell programs given a target shape and a primitive library, which compresses the design search dramatically. A third anticipated challenge in Aim 2 is morphogen crosstalk in vivo — real diffusible peptides do not cleanly separate into orthogonal channels — which is why the proposed in vivo demos start with a 1D axis only, and only then add a second orthogonal morphogen.

Section 6: Additional Information

References

• Gardner, T. S., Cantor, C. R., & Collins, J. J. (2000). Construction of a genetic toggle switch in Escherichia coli. Nature, 403(6767), 339–342.
• Elowitz, M. B., & Leibler, S. (2000). A synthetic oscillatory network of transcriptional regulators (the repressilator). Nature, 403(6767), 335–338.
• Atkinson, M. R., Savageau, M. A., Myers, J. T., & Ninfa, A. J. (2003). Development of genetic circuitry exhibiting toggle switch or oscillatory behavior in Escherichia coli. Cell, 113(5), 597–607.
• Alon, U. (2003). Biological networks: the tinkerer as an engineer. Science, 301(5641), 1866–1867.
• François, P., & Hakim, V. (2004). Design of genetic networks with specified functions by evolution in silico. PNAS, 101(2), 580–585.
• Beal, J., Lu, T., & Weiss, R. (2011). Automatic compilation from high-level biologically-oriented programming language to genetic regulatory networks. PLoS ONE, 6(8), e22490.
• Trewavas, A. (2014). Plant Behaviour and Intelligence. Oxford University Press.
• J. Craig Venter Institute. JCVI-syn3.0 minimal cell and full-cell simulation model release (2025).
• Source code for the morphology simulator: github.com/liamzebedee/morpheus

Supply List & Budget