neural_tile: a self-assembling tile computer in the abstract tile assembly model. A tile binds at a site when the summed strength of its matching glues reaches tau, which is the Heaviside gate H(strength.match - tau), so growth is governed by threshold neurons. Verified: the binding decision equals the gate; a general 2-input rule-tile set grows value(x,y)=f(W,S) for f in XOR/AND/OR (529 tiles each, checked against the recurrence, XOR = Sierpinski/Rule 90); a binary counter grows one integer per row (8-bit, 255 rows, row y encodes y) with carry by cooperative binding; both directed (deterministic). Turing-universal at tau=2 (Winfree 1998). Ships variants/neural_tile.safetensors (glue tables + binding-gate weights); eval_all skips it; README section and counts updated (9 standalone machines, 28-file family).

neural_ca: demonstrate gate composition. A third particle at (0,9) collides with the A&B output particle, so cell (3,5) carries A&B&C, verified over all 8 inputs; chained collisions build larger circuits from the interaction gate. README updated.

neural_ca: the collision is verified as a reversible interaction gate, not just AND. At step 4 three output cells carry A&B (deflected, (3,6)/(6,3)), A&~B ((6,6)), and ~A&B ((3,3)), checked over all four inputs. Analog robustness sweep on the matrix tile: exact under read noise through sigma 0.10 and conductance mismatch through sigma_G 0.10, matching neural_matrix8. README updated.

neural_ca: construct and verify a logic gate in the automaton rather than citing one. A billiard-ball collision between input particles at (2,2) and (7,7) leaves the deflected cell (3,6) occupied at step 4 iff both inputs are present; and_gate() checks the AND truth table over all four inputs. README and docstrings restated as plain technical description of the rule, the verified dynamics, and the constructed gate.

neural_ca: a reversible cellular-automaton computer with no processor. One fixed Margolus block rule (rotate 180, diagonal pairs swap) applied identically to every 2x2 block of a lattice, alternating partition each step. The rule is a self-inverse permutation of the 16 block states, so the whole lattice update is a bijection; verified reversible over random lattices, particle-conserving, with ballistic single-particle motion and deflecting reversible collisions (the billiard-ball model, Turing-universal by Margolus 1984). The rule is Heaviside threshold gates and compiles to a 6-layer ternary matrix tile that is a permutation with a 0.5 margin; that one tile applied to every block is one whole-lattice step, shipped as variants/neural_ca.safetensors. eval_all skips it; README adds the section and updates counts (8 standalone machines, 27-file family round-trip).

Give neural_attractor and neural_reversible a machine metadata field and eval_all skip entries, so python src/eval_all.py variants/ skips them cleanly instead of erroring (it scores fitness variants and skips standalone machines by that field). README sync: list both new machines in the variant table, intro, and repository layout; correct the standalone-machine count (5->7), the eval_all skip count (four->seven), and the universal-constructor family round-trip (23->26 files, 551->971 MB, both new files codec-verified byte-identical).

neural_reversible: structured reversible programs over the reversible ALU (reversible multiply with inputs preserved, Fibonacci whose inverse recovers the seed, a Janus conditional with an exit assertion); inverting a program is reversing the statement order and inverting each, and running the inverse recovers the input

neural_reversible: a register machine whose entire state transition is a bijection. Reversible threshold gates (CNOT/Toffoli/Fredkin as Heaviside AND/XOR), a reversible ALU (Cuccaro in-place adder, subtract as its reverse, negate/increment/rotate/word-Toffoli), and a reversible ISA with branch-register control. The single-step transition is verified bijective (step_back o step = identity over all instructions and branch states) and backward execution reconstructs the input; Bennett's construction realizes irreversible functions with clean ancillas. A bijective step erases no bits, hence no Landauer floor. All layers verified exhaustively at small width.

neural_attractor: tighten the README section and module docstring to a plain technical description (energy form, gate gadgets, clamped-subset modes, exactness and NP-hardness of the search modes)

neural_attractor: an energy-based threshold computer where computation is relaxation to a ground state and the program is the coupling matrix. No program counter, no clock, no forward-only execution: clamp any subset of wires and relax. AND/OR/NOT energy gadgets (each zero iff the gate relation holds) make it universal by construction; forward evaluation is exact, and clamping outputs runs circuits backward (an 8x8 multiplier compiled to couplings factors 35=5x7, 143=11x13) or solves SAT. Module, tests, artifact builder, and the shipped coupling matrix.

8-bit computer decode and PC sequencing as threshold gates: a 4-to-16 opcode one-hot decoder and a next-PC network (PC+2/PC+4 increment chains plus a priority mux over PC+2, PC+4, the conditional-jump mux, and the direct target). The runtime dispatches on the gate one-hots and takes the next PC from the mux instead of Python slicing and PC+2. Full 10/10 CPU suite passes; all variants rebuilt. Completes decode/PC-as-gates across every runtime (rv32, subleq, 8-bit computer).

rv32 decode and PC sequencing as threshold gates: an opcode-class detector network (exact 7-bit match per class), sign-extended immediate generation muxed over the I/S/B/U/J formats, and a next-PC mux (PC+4 / PC+imm / (rs1+imm)&~1). The threshold CPU reads these gate outputs for dispatch, immediates, and the next PC instead of slicing the instruction word in Python; verified in isolation and by the full RV32 lockstep suite plus randomized programs.

float FMA: fused multiply-add with a single rounding (F extension). A composed gate netlist (pre-normalize a/b/c, full product, dual sticky align shifters into a max-exponent field, cancellation-correct signed-magnitude add, normalize, one round-to-nearest-even, gradual underflow, full specials) for float16 and float32, validated bit-exact against the single-rounding oracle. FMADD/FMSUB/FNMADD/FNMSUB.S wired into the RV32 assembler, reference, and threshold CPU (gate-computed, lockstep-verified); composed FMA test in the eval suite; all variants and neural_rv32 rebuilt.

remove the superseded standalone float normalize stages from the core generators and their structure checks; the composed pipelines carry their own normalizers

float div: full IEEE subnormal support (pre-normalize both operands, then right-shift the aligned quotient by max(0,1-er) for gradual underflow); oracle validated bit-exact against numpy; all float variants rebuilt. add/mul/div subnormals now complete.

float mul: full IEEE subnormal support via a unified right-shift renormalizer (right-shift the product by F+1-min(nlz,exp_base)); oracle validated bit-exact against numpy over all classes including deep underflow; all float variants rebuilt

float add: full IEEE subnormal support (subnormal operands and gradual-underflow results) via effective exponent, implicit-bit selection, and a clamped normalize shift; oracle validated bit-exact against numpy float32/float16

rv32: FCVT.W.S honors the instruction rounding-mode field (RNE/RTZ/RDN/RUP/RMM), verified against an exact rational reference across all modes

neural_reflect: condense its README section to the family's house style; remove the version tag from the module and the model manifest

neural_reflect: host a complete SUBLEQ machine (32-byte memory, fetch-execute loop) inside the interpreter, its memory accessed through indexed addressing

neural_reflect: interpret the SUBLEQ datapath from stored gates; index-read scaling, a compiler from family nets, self-reproduction, self-rewrite, and sequential-state programs

neural_reflect: universal netlist interpreter with indexed addressing, two banks, and a compiler from family nets

Add neural_reflect: a threshold interpreter whose state holds its own weights

Move source library into src/; repoint module, tool, and README paths