Gemix — Seed Simulation

DNA seed sequence

A T G C

RNA 1 and RNA 2

A U G C

RNA 1

RNA 2

Waist (intergenic) RNA — both strands combined

Concatenated non-coding regions from RNA 1 and RNA 2.

RNA 1 waist

RNA 2 waist

Proteins

#	Start	Stop	Stop codon	AA len	One-letter

Altogether protein

RNA 1

RNA 2

Waist Ribosome — what hides in the non-coding RNA

Takes the combined waist RNA (RNA 1 waist + RNA 2 waist), runs the ribosome on it. Shows the proteins it would produce and the "waist of waist" — the leftover non-coding regions that still contain no ORFs.

Waist proteins

#	Start	Stop	Stop codon	AA len	One-letter

Waist altogether protein

Waist of waist RNA

Reverse: Protein → RNA

Given only the altogether protein chain, reconstruct an RNA strand that — when read by the ribosome — produces the same protein sequence. Each amino acid is mapped to its first possible codon, wrapped in AUG…stop per ORF. The result is verified by running it back through the ribosome.

RNA 1 → Reverse RNA

Input protein

Reconstructed RNA (codons)

Verification

RNA 2 → Reverse RNA

Input protein

Reconstructed RNA (codons)

Verification

Mirror → DNA reconstruction

Takes the reverse-engineered RNA (sense strand from the Reverse tab), computes its reverse complement (antisense/mirror strand), and converts the sense strand back to DNA (U→T). The two RNA strands and the reconstructed DNA are then verified by running the full pipeline and comparing the proteins.

Reverse-engineered RNA (sense)

Mirror RNA (reverse complement)

Reconstructed DNA

A T G C

Verification

3D Double Helix · RNA 1 & RNA 2

Interactive double helix of the two RNA strands. Drag to rotate/pan, scroll to zoom.

A U G C

Mix DNA · base-4 addition

Paste two equal-length DNA strands. The mutated output is mutated[i] = BASES[(A[i] + B[i]) mod 4] using A=0, C=1, G=2, T=3. The operation is a base-4 XOR: given the mutated strand plus either original, the other original can be exactly recovered — so the mutant can be split back into its two parents.

Strand A parent 1

0 bases

Strand B parent 2

0 bases

Mutated strand A ⊕ B

A T G C

Split / recover a parent

Paste the mutated strand and one known parent — the other parent is recovered exactly via other[i] = BASES[(mutated[i] − known[i] + 4) mod 4].

Mutated input

0 bases

Known parent A or B

0 bases

Recovered parent

A T G C

RSA Comms · DNA-only transport

Two keypairs are derived from DNA: P = next prime above the DNA-INT of one strand, Q = next prime above another. Then N = P·Q, T = (P−1)(Q−1), A is a prime exponent < T coprime with T (our "public exponent"), and B = A⁻¹ mod T is the private key. Alice encrypts protein codons with Bob's (N, A) → ciphertext integers get packed as fixed-width DNA (only DNA crosses the wire). Bob recovers the exact codons with c^B mod N. No symmetric key is ever shared.

Alice's keypair from RNA 1 & RNA 2

P = nextPrime(DNA-INT(RNA 1))not derived

Q = nextPrime(DNA-INT(RNA 2))not derived

N = P · Q—

Public exponent A—

Private exponent B—

Public key (N, A) as DNA—

Bob's keypair receiver

P (from random DNA A)not generated

Q (from random DNA B)not generated

N = P · Q—

Public exponent A—

Private exponent B—

Public key (N, A) as DNA—

seed bases

Alice → Bob · encrypt a protein encrypt with Bob's (N, A)

Source protein

Plaintext codons (RNA)—

Block size—

Ciphertext blocks (integers)

—

Ciphertext DNA (what goes over the wire) —

Bob decrypts decrypt with Bob's B

Bob receives the DNA ciphertext, splits it into fixed-width blocks, applies m = c^B mod N, unpacks each block into codons, and reconstructs the protein exactly.

Received DNA

Recovered codons—

Recovered protein (1-letter)—

Notes on the DNA-coin / double-spend problem

This tab shows the easy half of the idea: asymmetric DNA transport works — nothing but nucleotides crosses the network, and only the holder of B can recover the plaintext.

The hard half — a decentralized coin that prevents double-spend without a consensus layer — is open. Any copy of an owner's DNA wallet can sign the same transfer twice, and without some shared ordering authority (a chain, a DAG, a timestamp service, or a trusted hardware root) the two copies are cryptographically indistinguishable. A single "network seed DNA" plus recipient-mutating transfer does not solve it on its own: the attacker holds both the original and the mutated strands locally and can submit either one first to each of two different verifiers. Every practical approach we know of reintroduces some form of global ordering — just spread across many nodes.

Viable building blocks to explore: committee-signed UTXO mutations, verifiable delay functions over the seed DNA, rate-limited identity-bound wallets, or confidential-but-auditable logs (Certificate Transparency-style). None eliminates the authority; they only decentralize it.

RSA Keygen Calculator

Find closest primes, perform modular exponentiation, generate RSA keypairs from two primes, and encode/decode messages through the DNA256 codec.

Find Closest Prime prime

Number

Modular Exponentiation modpow

X

Y

Z

Keygen keygen

P

Q

Min A (optional)

DNA256 Codec dna256

Message

Secret (optional)

DNA256 strand (decode back to hex digest)

Text ↔ DNA

Same idea as DNA-INT, but for arbitrary text: UTF-8 bytes → big integer → base-4 DNA. Fully reversible. Each input byte becomes exactly 4 bases (plus a 4-base sentinel so leading-zero bytes survive the bigint round-trip).

encode Text → DNA

Plaintext

DNA (base-4 of UTF-8 bytes)

— nothing yet —

decode DNA → Text

DNA (length must be a multiple of 4)

Plaintext

— nothing yet —