Skip to main content

Plugins & Integrations

Zeq OS provides plugins for major game engines and web frameworks. Every plugin follows the same principle: replace the engine's internal time step with a Zeqond-synchronized time step locked to the HulyaPulse 1.287 Hz timebase. This produces deterministic, cross-platform physics and animation that is reproducible across any system running Zeq OS.

Integration Pattern​

All plugins share a common integration pattern:

  1. Intercept the engine's native deltaTime or frame callback
  2. Replace it with a Zeqond-synchronized delta derived from the 1.287 Hz HulyaPulse
  3. Modulate the time step using KO42 (see Metric Tensioners)
  4. Pass through to the engine's normal update loop

The engine continues to function normally — it simply receives a phase-locked time step instead of a free-running one.

Game Engine Plugins​

Unity — C# (HulyaSync.cs)​

using UnityEngine;

public class HulyaSync : MonoBehaviour
{
    private const float HULYA_FREQ = 1.287f;
    private const float ZEQOND = 0.777f;
    private const float ALPHA = 0.00129f;

    private float phase = 0f;

    void FixedUpdate()
    {
        phase += HULYA_FREQ * Time.fixedDeltaTime * 2f * Mathf.PI;

        float modulatedDelta = Time.fixedDeltaTime
            * (1f + ALPHA * Mathf.Sin(phase));

        // Use modulatedDelta for all physics calculations
        Physics.simulationTimestep = modulatedDelta;
    }

    /// <summary>
    /// Average over one Zeqond to recover unmodulated time.
    /// </summary>
    public float GetZeqondAverage(float value)
    {
        return value; // Modulation integrates to zero over 0.777s
    }
}

Unreal Engine — C++ (UHulyaSync)​

#include "HulyaSync.h"

const float UHulyaSync::HULYA_FREQ = 1.287f;
const float UHulyaSync::ZEQOND = 0.777f;
const float UHulyaSync::ALPHA = 0.00129f;

void UHulyaSync::TickComponent(float DeltaTime,
    ELevelTick TickType,
    FActorComponentTickFunction* ThisTickFunction)
{
    Super::TickComponent(DeltaTime, TickType, ThisTickFunction);

    Phase += HULYA_FREQ * DeltaTime * 2.0f * PI;

    float ModulatedDelta = DeltaTime
        * (1.0f + ALPHA * FMath::Sin(Phase));

    // Override world delta for synchronized physics
    GetWorld()->DeltaTimeSeconds = ModulatedDelta;
}

Godot — GDScript​

extends Node

const HULYA_FREQ := 1.287
const ZEQOND := 0.777
const ALPHA := 0.00129

var phase := 0.0

func _physics_process(delta: float) -> void:
    phase += HULYA_FREQ * delta * TAU

    var modulated_delta := delta * (1.0 + ALPHA * sin(phase))

    # Use modulated_delta for physics calculations
    Engine.physics_ticks_per_second = roundi(1.0 / modulated_delta)

Web Engine Integrations​

EngineHook PointSync Method
Three.jsrequestAnimationFrame loopReplace clock delta with Zeqond-modulated delta
Matter.jsEngine.update(engine, delta)Pass modulated delta to physics step
Cannon.jsworld.step(fixedTimeStep)Replace fixedTimeStep with modulated step
p5.jsdraw() loopOverride deltaTime global
D3.jstransition.duration()Scale durations by Zeqond factor
Plotly.jsPlotly.animate() frame timingLock frame intervals to HulyaPulse period

Three.js — Animation Loop Synced to 1.287 Hz​

import * as THREE from 'three';

const HULYA_FREQ = 1.287;
const ALPHA = 0.00129;
const TWO_PI = Math.PI * 2;

const clock = new THREE.Clock();
let phase = 0;

function animate() {
    requestAnimationFrame(animate);

    const rawDelta = clock.getDelta();
    phase += HULYA_FREQ * rawDelta * TWO_PI;

    // Zeqond-synchronized delta
    const delta = rawDelta * (1 + ALPHA * Math.sin(phase));

    // Update scene with synchronized time
    mixer.update(delta);         // Animation mixer
    physics.step(delta);         // Physics world
    renderer.render(scene, cam); // Render
}

animate();

Matter.js — Physics Step Sync​

const HULYA_FREQ = 1.287;
const ALPHA = 0.00129;
let phase = 0;

function gameLoop(timestamp) {
    const rawDelta = (timestamp - lastTimestamp) / 1000;
    lastTimestamp = timestamp;

    phase += HULYA_FREQ * rawDelta * Math.PI * 2;
    const delta = rawDelta * (1 + ALPHA * Math.sin(phase));

    Matter.Engine.update(engine, delta * 1000);
    requestAnimationFrame(gameLoop);
}

Benefits​

BenefitDescription
Deterministic cross-platform physicsSame initial conditions produce same results on any system
Synchronized multi-player stateAll clients share the same phase-locked timebase
Reproducible simulationsRe-running a simulation with the same seed and time offset produces identical output
Engine-agnosticThe same HulyaPulse frequency works in Unity, Unreal, Godot, and all web frameworks
Zero time-average distortionAveraging over one Zeqond (0.777 s) recovers the unmodulated result exactly

MCP Integration​

Zeq OS exposes itself as an MCP (Model Context Protocol) tool, allowing AI systems to invoke the framework's 1,576 operators directly. Zeq MI (port 3080) uses this integration to give conversational AI access to Mathematical Intelligence.

The MCP interface provides:

  • Operator invocation — call any of the 1,576 operators by name with typed parameters
  • Domain detection — route natural language queries through the D function
  • KO42 synchronization — all MCP calls are automatically tensioned
  • Result verification — precision guarantees apply to MCP responses the same as SDK calls

AI systems connected via MCP benefit from the full MI pipeline (MI(Q) = LLM . F . D(Q)) without needing to implement any framework logic themselves. The Zeq OS MCP server handles domain detection, operator selection, tensioning, and verification transparently.

Further Reading​