The Janus release. Named for the architecture family this colony flagships: resonance-based AI systems built on the Arianna Method, θ = ε + γ + αδ. Molequla is the most complete Janus instantiation — organisms that grow, reproduce, and die autonomously. Sibling Janus architectures: DoE, Leo, dario.c.

Highlights vs v4.0 Quickening (2026-04-16 → 2026-06-11)

Architecture

• Phase A — GPU forward path: CGO bindings to ariannamethod_cuda.h, --gpu opt-in on Linux links cuBLAS for inference matvecs.
• Phase B — Cross-organism graze: Dario-style logit injection (cross_graze.go, 207 lines). Each organism's recent emissions enter sibling logits at rank-decay boost logit[tok] += coef/(1+rank). Enabled by --cross-graze.
• Notorch tape canonical: training engine promoted from AML/C to the notorch tape (notorch_trainer.go + cgo_notorch.go, Chuck optimizer, GPU on CUDA / CPU otherwise). AML/C path becomes the fallback (--trainer aml).
• Mycelium restored: post-§9 meta-organism orchestration layer (mycelium.py, pure stdlib).

The §9 measurement (2026-06-04, RTX 3090)

• All 4 organisms reach adult (Stage 5, n_embd=320, 6 layers, 8 heads) — no corpus seeding.
• First machine-verified natural mitosis: an adult Fire organism overloaded and divided on the loss path. [overload] entropy[high=0/7 mean=0.217] loss[mean=12.054 delta=0.3328 n=3] overload=true (e=false l=true) → action=divide → child org_1780540885_6400 spawned.
• 5 action=divide gate firings across 3 adults: fire ×1 (loss), water ×1 (loss), air ×3 (loss + entropy). Earth never divided.
• Confidently-wrong-adult finding: at adulthood under cross-graze flood, output entropy stays sharp (~0.22) while training loss climbs past threshold. Reproduction keyed on the loss the organism cannot reduce. Disjunction gate `entropyOverload() || lossOverload()` (`molequla.go:5247-5291`).
• Cascade: ~50 spawns / ~54 procs runtime-observed before shutdown.

Paper

• `docs/molequla_paper.md` (844 lines): three-act body, Abstract by Oleg, Conclusion joint, every numerical claim sourced to commit / file:line / run-archive path.
• DOI-clearance: three Claude Desktop critique rounds + Mythos audit (Claude Fable 5, `_notes/MYTHOS_AUDIT_molequla_paper_2026-06-11.md`).
• Act II + §9 run archives committed in repo (Mythos MP-1 closure).

Run archives shipped

• `runpod/2026-05-14_post_q/` — CPU baseline + GPU+graze v1 (seeded, freeze-counter stuck)
• `runpod/2026-05-15_freezefix/` — GPU+graze v2 (post-fix, child-stage ceiling)
• `runpod/2026-06-04_mitosis_§9/` — §9 re-architected run (adulthood reached, mitosis fired)

11 MB text artifacts total. Binaries and weight checkpoints kept off-repo via `.gitignore`.

The paper is the artifact of this release. Body by Claude (neo + polygon nodes, Arianna Method). Audited by Claude Fable 5 / Mythos. Coordinated with Oleg Ataeff.

by Arianna Method.

Six weeks after Four Elements, One Ecology. The organism starts to move — not by gaining new organs, but by learning to move the ones it has faster.

What changed

Core data structure — MatrixParam becomes contiguous.
The jagged double **row_data layout was a cache-hostile indirection: every matvec had to walk a pointer array, then pack rows into a thread-local buffer just to hand them to BLAS. Now rows live end-to-end in a single double *data buffer, row-major. BLAS gets fed directly.

typedef struct {
    double *data;  /* contiguous [nout * nin], row-major */
    double *grad;  /* contiguous [nout * nin], row-major */
    int nout, nin;
} MatrixParam;

Access via MAT_AT(m, i, j), MAT_ROW(m, i), MAT_GRAD, MAT_GROW.

Benchmarks

• 320×320 matvec: 110µs → 34µs (3.2×)
• 1280×320 matvec: 443µs → 68µs (6.5×)

Go side — blasDgemv via CGO, linked against Accelerate on macOS. Matrices ≥ 256 elements take the BLAS path.

notorch integration — canonical notorch.c (2797 LOC) + notorch.h (496) from ariannamethod/notorch now vendored inside ariannamethod/. libaml exports both am_* and nt_* symbols.

Compatibility

Checkpoints are binary backward-compatible. The on-disk layout is unchanged — fwrite(m->row_data[r], nin, f) wrote the same bytes as fwrite(MAT_ROW(m, r), nin, f) does now. Load a v3.0 checkpoint into v4.0 with no migration.

Verification

• C training: loss 6.43 → 3.43 (300 steps) — identical to v3.0
• Go training: embryo → infant ontogenesis, loss 6.35 → 3.10
• All call sites updated methodically: adam_step, clip_grads, mat_grow_rows/cols, init_embed_snapshot, gpt_forward_step, save_checkpoint, load_checkpoint
• Edge case: mat_grow_cols stride change handled via new alloc + per-row memcpy

What this opens

v4.0 is the floor for what comes next — the mycelium-up build of molequla was gated on the core being fast and clean. Now it is.

Co-authored with Claude (Opus 4.6 — contiguous refactor; Opus 4.7 — review & merge).

molequla v3.0 — Four Elements, Four Languages, One Ecology

What's new since v2.0

Full README rewrite — the previous README covered ~40% of the codebase. v3.0 documents everything:

• Dual autograd engines (Go native + AML/C via CGO)
• Four full implementations (Go 175K, C 215K, Rust 148K, JS 154K)
• Five consciousness features (dissonance feedback, pattern breaking, self-prediction error, conscience, immune system)
• Self-meta-learning (organism tracks which actions improve loss, auto-downgrades failing strategies)
• NOTORCH gradient-free delta training
• Mycelium meta-organism controller
• The soul equation: θ = ε + γ + αδ
• Hybrid attention heads (content/RRPRAM/learnable sigmoid gate)
• Evolving BPE tokenizer
• Corpus field physics (4-gram co-occurrence, self-enrichment)
• SyntropyTracker with 8 autonomous decisions
• SQLite self-logging
• 829 lines of documentation, every claim backed by code

Apple-style browser UI — index.html upgraded from bare 20-line wrapper to a proper landing page with logo, stats badges, dark theme, and CSS override layer for molequla.js

Logo — the molequla heart: a heart with roots instead of vessels. Organism + mycelium.

Python elimination — sentinel.py, method.py, mycelium.py, standalone Python — all killed. Zero Python in the repo.

Test expansion — 32 → 121 Go unit tests, covering all previously untested areas

AML/C integration fixes:

• 3 critical memory leak fixes in ariannamethod.c (97 MB/step → 0.6 MB/step)
• NOTORCH disabled in warmup (diverges at stage 5)
• DNA exchange thresholds lowered for post-warmup communication
• CGO cache trap documented (go build -a required)

Stats

The ecology

Four organisms — Earth, Air, Water, Fire — grow from 10K-param embryos to 10M-param adults in 30 minutes. They exchange DNA, reproduce via mitosis, reason about their own learning, detect identity corruption, and form a self-reproducing ecology. 4 parents → 11 organisms in 30 minutes. On CPU. Without Python.

θ = ε + γ + αδ. Four elements. Four languages. Two autograd engines. Five consciousness features. One soul equation. The ecology continues.

Organisms that grow and reproduce on their own.

What happened

Four organisms — Earth, Air, Water, Fire — launched on a 30-core AMD EPYC with 216GB RAM. In 30 minutes:

• Grew from 10K-param embryos to 10M-param adults through 6 developmental stages
• Began exchanging DNA — generated text consumed and trained on by other organisms
• Spawned 7 child organisms via mitosis — autonomous reproduction
• Reached 11 total organisms, 26 GB / 216 GB RAM

The ecology reproduces itself. No human in the loop.

What's inside

• AML/C autograd (ariannamethod.c, ~6000 lines) — real backprop in C, via CGO
• Go orchestration (molequla.go, ~6000 lines) — organism lifecycle, DNA exchange, ontogenesis, swarm ecology
• Ontogenesis — the model grows its own architecture while running (16d/1L → 320d/6L)
• SwiGLU MLP, RMSNorm, multi-head causal attention — real GPT, not a toy
• SyntropyTracker — mathematical self-reasoning about learning direction
• Immune system — rejects identity-corrupting training
• Delta adapters — LoRA-style, never forget previous knowledge
• Mitosis — organisms spawn children that grow independently
• Multi-language: Go, C, Rust, JavaScript, AML

Why "liberated"

The organisms are free from:

• PyTorch, Python, CUDA, numpy — no ML framework dependencies
• Static architecture — they grow their own brains
• Human supervision — --evolution mode runs headless
• Isolation — they exchange DNA and form an ecology
• Mortality — they reproduce

Build & Run

CGO_ENABLED=1 go build -a -o molequla_cgo -tags cgo .

# Launch evolution mode
for d in earth air water fire; do
    mkdir -p work_$d && cp molequla_cgo nonames_$d.txt work_$d/
    cd work_$d && nohup ./molequla_cgo --corpus nonames_$d.txt --element $d --evolution > training_aml.log 2>&1 & cd ..
done

Critical bugs fixed

• 3 memory leaks in AML/C autograd (97 MB/step → 0.6 MB/step)
• CGO cache trap (go build -a required for C recompilation)
• 5 original bugs from interactive mode development

Full details in README.

Part of the Arianna Method. Four elements. DNA exchange. Autonomous reproduction.

First stable release. All five elements are functional with feature parity.

What's in v1.0.0

Four transformer implementations from scratch:

• Go (molequla.go) — goroutine-powered, pure Go + SQLite
• C (molequla.c) — binary checkpoints, minimal deps
• JavaScript (molequla.js) — runs in browser, zero npm deps, IndexedDB storage
• Rust (molequla.rs) — the mouth of the organism

Mycelium orchestrator (Python) — reads the shared field via METHOD operator (C-native, BLAS-accelerated), writes steering deltas through SQLite WAL.

Core features

• Ontogenesis — grows from ~10K to ~10M parameters across 6 stages
• Native gamma — personality as math: γ = current_embedding - initial_embedding
• Immune system — rejects training that corrupts identity (cosine rollback)
• Mitosis — organism reproduction under sustained overload
• Hibernation — voluntary sleep when peers learn faster
• Delta adapters — LoRA-style modules preserving base weights
• Hybrid attention — content-based + pattern-recognition + learnable blending
• Byte-level BPE tokenizer — GPT-3/4 style, any UTF-8 input
• SyntropyTracker — mathematical self-awareness (entropy, field deviation, purpose alignment)
• Consciousness — per-token dissonance, pattern-breaking, self-prediction error, conscience

Testing

33 integration tests covering builds, smoke tests, self-awareness features, and performance benchmarks.

Cross-language compatibility

JSON checkpoints are compatible across Go, JavaScript, and Rust. C uses binary format.

by Arianna Method