Introduction

Vibe Theory treats reality as one thing, a vast growing crystal of experience. The image above is its simplest face, the hyperbolic {7,3} tessellation, and it is meant literally. Each tile is a vibe, the smallest unit of experience. Each vibe carries a ternary tone, its felt charge, shown as a color: red is pain, green is peace, blue is pleasure. Tiles that touch are vibes that note (experience) one another, so the edges of the crystal are the relations of the mesh. There is nothing else in the model but this.

To hold it at a glance: a single tile is one quantum of experience, a patch of tiles is a thing or a mind, and the whole crystal is the universe, growing forever at its ever-receding edge, which is the present. The geometry is hyperbolic because that is the shape roomy enough to grow without end and with no preferred direction, so it respects relativity. Everything we call physical, space and time and matter and force and gravity, and everything we call inner, sensation and emotion and thought, is a large-scale pattern in this one colored, growing mesh of feeling.

The flat {7,3} picture is the easy-to-draw two-dimensional face. The committed substrate is one member up the same family of regular hyperbolic honeycombs, the four-dimensional {3,4,3,4}, whose cells are 24-cells and whose 24 directions form the D4 root system that carries spin. Its flat three-dimensional cusp is the physical space we live in, and time is its growth. The three-dimensional {5,3,4} and the two-dimensional {7,3} are the lower faces used to build intuition, since {3,4,3,4} cannot be drawn directly. The dimension is not a free choice. Regular hyperbolic honeycombs run out by the fifth dimension, and {3,4,3,4} is the one that is at once crystallographic, spinor-carrying, and three-dimensional where physics lives.

The base of the model is settled, the discrete substrate and its single local rule. From it the architecture of physics is derived: the particles and their charges, the gauge group, the Higgs, the shape of the mass hierarchy, and the emergent laws of relativity, gravity, the quantum, holography, and cosmology. The absolute masses and couplings are free, exactly the parameters the Standard Model leaves free, each now identified with a specific geometric origin. One deep question is still open and flagged as such: whether the model forces exactly the three generations of matter we observe. The larger aim is to derive space, matter, gravity, the quantum, cosmology, and mind from the one rule, and to be clear at every step about what is solid, what is free, and what is still open. The companion papers are snapshots of that work.

What this repo is

@cluesurf/vibe is a finite, discrete, reproducible simulator that turns the theory into runnable measurements. It is the bench where the model is built, stress-tested, and checked against known physics. It generates the discrete substrate (the mesh), runs the one local rule over it in discrete beats, and measures what emerges, so each question becomes a concrete experiment that either works or does not.

Everything is finite and deterministic, so every result is exactly reproducible. The base never relies on randomness. Real numbers appear only as measured outputs (coordinates, eigenvalues, dimensions), never as the base, in keeping with the discreteness principle. Much of this code was written with AI assistance, which changes nothing about trusting it. It is deterministic and reproducible, so you can run it and verify every result yourself. Each question is one experiment in test/experiment/<category>/, a single experiment that returns a structured verdict (status, metrics, control, claim) graded by an honest depth level, from L0 circular through L1 known math and L2 known physics to L3 emergent and novel. The standard the experiments are held to is in note/experimental-methodology.md, and the code and test layout is in note/architecture.md.

Depth levels

Every experiment self-grades by what it actually establishes, not by whether it prints PASSED. This is the depth column in test/catalog.csv, which is sorted so the strongest results come first.

| level | meaning | | ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | L3 | emergent and novel. One base rule produces the result as a measured consequence, with a control, ideally a quantitative prediction that could be wrong. The genuine target. | | L2 | known physics. Reproduces a known construction on the substrate (a Dirac quantum walk, lattice gauge theory, a ballistic light cone). | | L1 | known math. Correctly confirms an established mathematical fact (the 24-cell is the binary tetrahedral group, a 2pi rotation gives minus one). | | L0 | circular. The answer is put in by hand, so it proves nothing on its own. Kept only as an honest consistency note, never as evidence. |

So L3 is the real prize, L1 and L2 are honest groundwork, and L0 is a marker of what is assumed rather than derived. Most results in a young program are L1 and L2, and that is fine as long as they are labeled as such. The full rubric and the rules the runner enforces (an L3 claim must carry a control, for instance) are in note/experimental-methodology.md.

Quick start

pnpm install
pnpm test         # the full experiment registry plus the conformance battery
pnpm test:full    # the above, then the extended check suite

Every experiment lives in test/experiment/<category>/<name>.ts as one experiment, and the suite runner (test/run.ts) imports them all and runs the registry. The shared library they import is in code/, and the named batteries (conformance, paper) are in test/suite/. The build fails only on a code crash or a conformance failure, never on an honest scientific negative.

Defining the model

The model reads at a glance through a small DSL (code/model/vibe.ts). With no options it is the working model, and one-word swaps express variants for comparison. No string is ever evaluated, so this is a constructor, not runtime codegen.

const model = vibe().size(1500).seed(1) // the working model
console.log(model.describe()) // print the model at a glance
const world = model.build().run(40) // build the mesh, run 40 beats
world.read() // emergent structures read off the same mesh

The substrate generators build the exact regular honeycombs, including the two-dimensional {7,3}, the three-dimensional {5,3,4}, and the committed four-dimensional {3,4,3,4} with its O(log n) addressing, alongside random hyperbolic, lattice, and sprinkled comparison meshes. Swapping to a flat lattice gives a preferred frame and breaks isotropy, which is why a curved mesh is the committed choice.

What is inside

• substrate: regular {p,q,...} hyperbolic honeycombs through the Coxeter engine, including the {3,4,3,4} cell graph with O(log n) addressing, plus hyperbolic random graphs, regular lattices, Minkowski and curved sprinklings, and classical sequential growth.
• tone: the ternary alphabet and the directional fill carried on each cell.
• rule: synchronous, asynchronous, reversible, rewriting, and gauge updates.
• operator: graph Laplacian, Kahler-Dirac and overlap fermions, the gauge-covariant Dirac, the cellular-automaton Hamiltonian, and the gauge index.
• algebra: quaternions and the binary tetrahedral 24-cell, the D4 and F4 root systems, spinor and vector rotation, Clifford and exterior calculus, and the linear-algebra kernels (Lanczos lowest eigenvalues, the kernel-polynomial method, Bethe resolvents).
• measure: dimension, distance, curvature, manifold-likeness, Lorentz isotropy, streaming BFS shells, navigation, CHSH, locality, integration, Wilson loops, and Aharonov-Bohm phase.
• dynamics: the Benincasa-Dowker action, uniform-measure and Wang-Landau sampling, parallel tempering, coarse graining, and the Wilson heat bath.
• control: the negative controls that make a positive result mean something (the substrate or rule where the answer must be no).
• draw, render, and viz: renderers and figures for the bulk, the cusp, gliders, gravity, and the nesting tower.
• test/experiment: one experiment per question, grouped by category (foundations, geometry, relativity, spin, gauge, gravity, cosmology, holography, quantum, renormalization, selves, computation, addressing, substrate-survey, data-structure), run by the suite runner in test/.

Documentation

All docs live in note/. The entry points:

• The library guide is how to USE the code/ library. It opens with a features-at-a-glance page (what the library solves for in one scannable set of tables) and an overview of how it all fits together. Under that are per-domain API guides (substrate, tone-and-rule, operator, measure, dynamics, algebra, model, tool, computing-and-data-structures, draw-and-render) and engine deep dives explaining how each engine works inside (the Coxeter tessellation engine, the reversible rule, the Kahler-Dirac fermion, the spinor coin, the spectral methods, the causal-set sampler, the unitary evolution, the lattice gauge engine, the coarse-graining and selves engine, and the associative memory engine).
• Architecture is where code and tests live, and how to add an experiment.
• Experimental methodology is the standard every experiment is held to, the depth rubric, the control requirement, determinism, and the honest negatives.
• Cross-tessellation experiments is how to write an experiment that runs against every regular hyperbolic tessellation at once.

License

MIT. Open for science: use, modify, and build on it freely, with attribution. See LICENSE. The written results and figures are shared under CC-BY-4.0 (attribution).

ClueSurf

Made by ClueSurf, meditating on the universe ¤. Follow the work on YouTube, X, Instagram, Substack, Facebook, and LinkedIn, and browse more of our open-source work here on GitHub.