I'm a self-taught developer working at the intersection of optimization, pattern formation, and cellular automata.
I build experimental systems where complexity emerges from simple rules — using code, recursion, and a bit of imagination.

Exploring fractals generated from symbolic billiards, irrational discretization, and curved surface slicing. A bridge between number theory and emergent geometry.

→ billiard-fractals

→ full article

Genetic algorithm that evolves cellular automaton rules to maximize specific behavior (like flickering, stability, or growth).

→ evolving-cellular-automata

→ full article

A genetic algorithm evolves the initial field state of a cellular automaton while keeping the rules fixed.
The goal: observe what kinds of behavior or structures can emerge from a Turing-complete substrate.
It’s a search for dynamics, complexity, or stability — without touching the rules themselves.

→ initial-state-evolution

Fractal patterns generated via recursive substitution, then evolved using a genetic algorithm.
Focus: visual symmetry, self-similarity, and how simple logic creates structured complexity.

→ fractals

→ full article

Fractals from a single point — grown using either cellular automata or convolution kernels. This project explores 6 minimal systems that all follow the same basic idea: Start with a tiny seed, apply a deterministic transformation, pad or copy, repeat. Fractals emerge.

But here’s the twist — CNNs (convolutional neural nets) do the same. They copy, convolve, repeat. So what happens when we apply the same kernel over each iteration? You get... fractals. Turns out, when a neural net "draws a cat", it draws a fractal that looks like a cat.

→ fractogenesis

Fractals generated by recursively permuting pixel arrays via a quadrant-based shuffle operation.
This deterministic process reveals deep structural symmetries in both binary and full-color images.

The method echoes spatial structure-modification routines found in convolutional architectures (e.g., padding and upsampling),
though it diverges from convolution by applying no local aggregation — only recursive, deterministic reordering.

→ perfect-shuffle

→ full article

A generative MIDI tool that evolves musical patterns using deterministic shuffling and genetic algorithms. Built with Node.js + MIDI export.

→ perfect-shuffle-music

Artificial life on a grid: each particle is controlled by a neural network.
They move, sense, and fight — evolving through a genetic algorithm.
The goal isn’t predefined — just survival, competition, and strange emergent behaviors.

→ neuroparticles

A minimalist encryption scheme based on recursive, invertible spatial shuffling.
Pure, deterministic logic with visual twist.

→ perfect-shuffle-cryptography

Interactive 2D particle system with electric-like forces and edge wrapping.
Built in JavaScript with live controls for mass, charge, and interaction strength.

→ particles

Tiny sandbox to create layered fractals by scaling and overlaying a simple pattern.
Playful and deterministic — showing how recursion builds structure from almost nothing.

→ t-fractal

• Emergence, recursion, and transformation
• Genetic algorithms and search-space exploration
• Cellular automata as minimal computational universes
• Visual representations of abstract systems
• Metaphysical math (no mysticism — just weird consequences of logic)

JavaScript · Node.js · Canvas · HTML
Comfortable with C++, Python, Arduino, and some lower-level stuff if needed.

• Originally from Ukraine 🇺🇦 — currently in Ireland
• Former Habr.com author (writing deep-dive articles on algorithms and visual systems)
• Reformatting my past work for GitHub
• Fluent in math, logic, and frustration-driven debugging

Serhii Herasymov
📧 sergeygerasimofff@gmail.com
🔗 github.com/xcontcom

Complexity isn't magic — it's just logic repeated until it surprises you.