Krestianstvo Wavefront Evaluator — Overview

The Krestianstvo Wavefront Evaluator (KWE) is a computational engine that replaces the traditional virtual-machine execution model with wavefront propagation. Rather than routing causality through a central message scheduler, KWE propagates effects as physical waves through a graph of locally autonomous nodes — each node that receives a message becomes a secondary wave source, directly instantiating Huygens’ principle in software.

This design yields deterministic multi-peer synchronisation as a structural consequence of the execution model, not as an engineering add-on. KWE combines the Renkon reactive programming model with the Croquet synchronisation architecture. A light-cone causality structure — local queues in which messages can only affect future states — guarantees that effects never precede causes.

Given identical initial state (“initial energy”) and identical program (“laws of physics”), any number of peers converge to the same state without exchanging simulation data.

The central novelty is the Fractal Time Generator — an IFS fractal clock: a self-similar cascade of virtual-time beats generated by an Iterated Function System whose contraction ratios span multiple spatial and temporal scales. This cascade unifies time-stepping, spatial quadrature, wavelet decomposition, and distributed synchronisation in a single mechanism.

Physics simulations — wave propagation, holography, strange attractors, and nonlinear Schrödinger solitons — serve as proof-of-concept workloads that stress-test the engine’s determinism and causal correctness across peers. All examples run live in the web browser sharing a WebSocket reflector and remain pixel-exact across peers.

Introduction

The synchronisation problem in distributed systems is conventionally treated as an engineering challenge: how to reconcile divergent state across nodes that execute independently. Classical approaches either replicate state (expensive bandwidth), run independent simulations with periodic reconciliation (divergence risk), or serialise all computation through a central server (latency bottleneck).

KWE takes a different starting point: since information propagation in physical space follows causal laws, why not make the execution model directly isomorphic to those laws?

The result is a Deterministic Distributed Wavefront Evaluator. It abandons the traditional linear-list execution model and adopts the laws of wave propagation as its computational substrate. Every node is locally autonomous; causality propagates as a wavefront rather than being routed through a scheduler.

The Croquet model provides the reflector layer: all non-deterministic inputs are routed through a lightweight WebSocket server that stamps them with a shared logical timestamp. Each peer then re-executes the same deterministic program independently. No simulation state traverses the network beyond the initial snapshot and the event stream. KWE extends this model with a reactive execution layer (Renkon) and a novel physics substrate based on fractal time.

Local-First Computation in Multi-Peer Architectures

Because KWE is designed to run across multiple independent peers, global synchronisation is not merely expensive — it is architecturally incompatible with the model.

Scalability. There is no global state that peers must agree on before proceeding. The field state at any moment is simply the accumulated sum of local shell contributions from all peers’ independently-firing beats. Adding more peers does not introduce new synchronisation requirements; each peer contributes its local events, and the global field emerges from their superposition.

Fault tolerance. If a peer drops mid-cycle, its missing shell contributions produce a localised reduction in field intensity in that spatial region — the soliton does not collapse globally, and the fractal beat cascade on surviving peers continues uninterrupted. The damage is proportional to the dropped peer’s spatial coverage, not to the whole system.

Waves are inherently local phenomena: a wavefront interacts only with its immediate neighbourhood at each moment. The Fractal Time Generator beat cascade respects this by approximating the global Fresnel integral as a hierarchy of local shell events. The global field state does not need to be explicitly assembled anywhere — it emerges from the causal propagation of beats through the tree, exactly as a physical wavefront emerges from the local interactions of its constituent elements.

Computer as Calculator vs. Computer as Medium

A standard spectral simulation treats the computer as a calculator operating on a matrix. To advance the field by one time step, the entire grid is frozen, transformed into frequency space via FFT, physics is applied globally, and the result is transformed back. The wave does not travel through this process — it is teleported from state T to state T+1. There is no causal in-between; there is only the transition of the matrix.

KWE treats the computer as a medium. Because each grid point acts as a source of secondary wavelets (Huygens-Fresnel principle), the simulation is causal by construction. A simulation of a ripple doesn’t wait for the whole grid to update. A ripple in the center of your screen radiates outward, hits a neighbour, and triggers the next “beat.” This is simulating the propagation delay of the light/wave itself. The IFS Fractal Clock creates a topology where the distance between two points is represented by the time (the delay) it takes for an event to reach from one to another.

The computer isn’t calculating the wave; the computer is being the wave.

The way these two systems “see” space is fundamentally different, which changes how they handle energy (like solitons):

Grid vs. tree topology. In a matrix simulation, space is a flat uniform array — every pixel equidistant from its neighbours, no depth, no scale hierarchy. In KWE, space is hierarchical and multi-scale. Because the IFS clock breaks down the simulation into nested shells of increasing depth, your simulation acts like a fractal medium. High-frequency waves (fine details) live in the “small branches” of the tree, and low-frequency waves (global trends) live in the “root.”

Non-Locality. In a matrix-based simulation, adding long-range interaction (like a Fractional Laplacian) is computationally expensive because it breaks the FFT. In the IFS tree, adding long-range interaction is just a matter of adding a beat event to a deeper or shallower branch of the tree.

Emergent Stability. In a matrix transformation, if you have a numerical error, it pollutes the entire grid (global aliasing). In a medium-based simulation, an error acts like a “noise” or “distortion” in the signal. The wave can pass through it and recover because the simulation is inherently dissipative and self-correcting.

A matrix-based simulation produces a sequence of frames — a movie computed offline. KWE produces a live experiment: a system reacting to its own causal history. The soliton is not a data point in an array; it is a coherent state propagating through a fractal topology. The shift is from solving an equation to building a substrate in which the equation is the law of physics.

Temporal Lens: Bridging Spatial and Temporal Transforms

There is a structural duality between optical physics, functional programming, and multi-scale time that runs through the KWE architecture. While a physical lens acts as a spatial Fourier Transform, the IFS fractal clock acts as a temporal Wavelet — or Scale — Transform.

In optical computing and holography, a physical glass lens is literally a hardware implementation of the Fourier Transform: it maps spatial coordinates (x, y) to spatial frequencies (fx, fy) at its focal plane. This is why brute-force wave propagation scales at O(N⁴) complexity.

The IFS fractal clock occupies the same role in the time dimension. Instead of processing time as a flat linear stream of uniform ticks, the IFS clock modulates the distribution of sub-ticks using an Iterated Function System invariant measure. Because it uses self-similar scaling to cascade events down through simulation depth layers D0, D1, D2, …, it behaves not like a Fourier transform but like a Continuous Wavelet Transform or Mellin Transform — treating time as a multi-resolution fractal fabric where high-frequency bursts are nested inside low-frequency macro-ticks.

Three analogous transforms sit side by side:

The spatial lens of optics focuses raw light phases into spatial frequencies (x → f)
The functional lens of FRP focuses a global state object into a local sub-state (State → SubState)
The IFS clock lens focuses a global macro-tick into localised, multi-scale sub-tick cascades (t → Scale)

Physics Simulations as Proof-of-Concept

Physics simulations in KWE are not the primary goal — they are proof-of-concept workloads chosen specifically because their correct behaviour is visually and numerically verifiable, and because they stress-test causal correctness, floating-point determinism, and multi-peer consistency simultaneously.

2D Cellular Wavefront

The simplest example demonstrates the core distributed model. A 15×15 grid of 225 independent cell behaviours, each listening for wave messages. Clicking any cell broadcasts a userWave event through the reflector; each cell schedules an activate message delayed by dist × WAVE_STEP_MS virtual milliseconds, producing a Huygens-style expanding wavefront.

Holography: Huygens Back-Propagation

Classical digital holography on a 64×64 plate. IFS beats scatter Huygens wavelets from 192 cube-edge source points onto concentric rings of the hologram plate. A second IFS cascade then performs back-propagation — building the reconstruction in row-strips of 4 rows per beat.

Holography: IFS-Native Wavelet

A wavelet-native pipeline on a 128×128 grid. The IFS beat cascade partitions the plate field into per-depth sub-band images via isotropic ring sampling. Each band captures one spatial-frequency octave. Reconstruction is a weighted sum with unsharp masking. Clicking individual band panels toggles bands in/out in real time — a capability unavailable in classical Huygens holography.

Nonlinear Schrödinger Solitons

The 2D focusing nonlinear Schrödinger equation with saturable nonlinearity on a 64×64 complex field ψ. The fractional Laplacian is implemented via the isotropic Fractal Time ring kernel; its effective order s_eff ≈ 0.82–0.85 emerges from the IFS contraction geometry rather than being set explicitly.

Implementation Overview

Renkon Reactive Model

Renkon is a dataflow reactive programming system in which programs are expressed as graphs of behaviours (continuously valued signals) and events (discrete occurrences). A Behaviors.collect(init, trigger, updater) node accumulates state by applying updater(state, pulse) each time trigger fires. This model maps naturally onto the event-driven beat cascade.

Croquet Synchronisation

The synchronisation layer follows the Croquet model: a lightweight WebSocket reflector server echoes heartbeat pulses to all peers in a selo (shared session). No simulation state traverses the network beyond the initial snapshot. When a new peer joins, an existing peer serialises its world state via takeSnapshot() and sends it; the joining peer calls applySnapshot() to restore the full behaviour state.

W.reduce and the Virtual Queue

The core runtime primitive is W.reduce(state, pulse, nodeId, handlers). It maintains a per-node priority queue of scheduled messages ordered by virtual fire-time. On each reflector heartbeat, the drain loop advances virtual time by up to SUBTICK_MS milliseconds per JS turn, processing all ready messages.

Deterministic PRNG

The evaluator includes a deterministic xorshift128+ PRNG (W.rng) to ensure all peers produce identical random sequences from the same seed. All peers seeded identically will generate the same values in the same order — guaranteed consensus on randomness.

Summary

Krestianstvo Wavefront Evaluator demonstrates that replacing the virtual-machine execution model with wavefront propagation yields deterministic distributed computation as a structural property rather than a protocol.

Key results:

Wavefront execution model — causality propagates as a wavefront through locally autonomous nodes rather than through a central scheduler
Deterministic multi-peer convergence in the browser with no simulation state over the network
IFS fractal time generator as unified substrate — a single mechanism drives time-stepping, spatial quadrature, wavelet decomposition, and distributed synchronisation
Emergent fractional dispersion in the NLS system — the effective fractional order s_eff arises from the IFS contraction geometry, not from a free parameter
Non-blocking distributed computation — the drain loop spreads expensive computation across many heartbeats without blocking the UI thread

What Runs in the Browser — Today

All of the following run live in a web browser, synchronised across peers via a WebSocket reflector, pixel-exact on every connected window:

2D Cellular Wavefront — 225 independent nodes, Huygens-style expanding wave
Fractal Heartbeat — self-similar cascade of beats at five temporal scales
Lorenz / Rössler Strange Attractors — driven by fractal time, coloured by depth
Holography: Huygens Back-Propagation — 64×64 holographic plate, cube wire-frame object
Holography: IFS-Native Wavelet — 128×128 multiresolution hologram with toggleable bands
NLS Solitons — stable self-organising wave packets, live injection by click
Soliton Collision — two-soliton pass-through across split browser windows
Topological Instantons — A→B vacuum tunneling driven by vortex injection
Instanton Hologram — recording and reconstructing a topological event
Holographic Eye — live observer that perceives a wavefront as a soliton eigenstate

Future Directions

The wavefront execution model opens several research directions:

Distributed collaboration tools, multiplayer games — domains where physical intuition about causality may be closer to the essence of the problem than traditional message-passing architectures
3D volumetric holography — extending the IFS clock to three spatial dimensions
Adaptive dispersion — making the emergent fractional order s_eff controllable by adaptive selection of IFS contraction ratios
Time-travel debugging — replaying the beat history from any saved state, exploiting the fact that all randomness is seeded deterministically from the cycle index
IFS approach to LLM attention — O(N) causal propagation in place of O(N²) barrier, trainable via spike-timing-dependent plasticity