fpsr

Apache License 2.0—see LICENSE for details.
Copyright (c) 2025 Woo Ker Yang (Patrick Woo) patrickwoo.1976@gmail.com
If you reference or adapt this framework, please credit Patrick Woo and this repository.
This documentation is still in development.
While every update aims for accuracy, some parts may still be incomplete or contain inaccuracies. I appreciate your understanding in this matter, and we apologize for any inconvenience this may cause.

🎲 FPS-R Algorithm: Frame-Persistent Stateless Randomisation

Table of Contents

🗺️ A Site Map of the Documents

%%{ init: { "theme": "neutral" } }%%
graph TD
  A[**README.md** 🏁<br>Manifesto & Overview] --> A2[Read-Me] 
  A2 --> A3[Technical]
  A2 --> A4[🧬 Origins, Journal,<br>Reflections<br><br>🧬 Origin story,<br> 🧠 Thoughts & Philosophy,<br>📓 Developer Journal]
  C[**README-CH.md** 🈸<br>Manifesto in Chinese] --> A2
  A3 --> B[**Tech.md** 📐<br>Maths & Code]
  A3 --> D[**Applications.md** 🍭<br>Cross-Domain<br>Use Cases]
  %% A4 --> E[**Dev_Journal.md** 📓<br>Developer's<br>Journal]

  %% A4 --> F[**Origins.md** 🧬<br>Origin Story] 
  %% A4 --> G[**Thoughts.md** 🧠<br>Reflections &<br> Conceptual Notes]

  classDef fileStyle fill:#A2A2A2,stroke:#333,stroke-width:1px,color:#000,rx:16,ry:16,font-size:15px;
  classDef techHighlight fill:#799F92,stroke:#444,stroke-width:1.5px,color:#E8E8E8,rx:16,ry:16,font-size:15px,font-style:italic;
  classDef thoughtsHighlight fill:#AFA279,stroke:#444,stroke-width:1.5px,color:#E8E8E8,rx:16,ry:16,font-size:15px,font-style:italic;
  

  class A,C,A2,A3 fileStyle
  class B,D,A3 techHighlight
  class A4,E,F,G thoughtsHighlight

📜 Readme — Manifesto (English)

You are here. This is the primary document. It presents FPS-R as both a motion grammar and a collection of expressive tools, and serves as a lens through which to understand not only how FPS-R functions, but also why it evokes the qualities it does.

🈸 Readme — 宣言,理念描述 (Chinese)

Click here: 自述文件 — 中文版 (README-CH.md) The Chinese edition of the manifesto, presenting the philosophical and expressive foundation of FPS-R in Mandarin.

📐 The Mathematics and Mechanics

Click here: fpsr_tech.md This extension document provides the structural foundation beneath the conceptual framing. It outlines the algorithms, expressions, parameters, and architectural elements that support and shape the behaviour of FPS-R. The code lives here.

🍭 Applications

Click here: fpsr_applications.md This document complements and extends the applications of FPS-R beyond the high-level summarised view provided in this ReadMe file. The document will dig deeper into each domain and provide larger number of use cases for each area of use.

🧬 Origins, Journal, Reflections

Click here: fpsr_origins_journal_reflections.md This document consists of 3 large sections:

🧬 Origins This is the history and the story of FPS-R. It recounts the events that led to the discovery of each algorithm, and tells about the persistent pursue of the language of motion, about discovering meaning and refining the mechanics behind move and hold. It will also tell how each algorithm revealed itself, and how they come together to form the FPS-R framework.

🧠 Reflections and Thoughts An archive of nonlinear reflections, theoretical digressions, and design meditations that contributed to the philosophical development of FPS-R. This document functions as a conceptual incubator and critical sketchpad, recording my internal struggles and conflicts. It also provides the philosophical and poetic dimensions of FPS-R’s evolution—where structure meets sensation, and randomness finds rhythm.

📓 Development Journal A chronological account and living notebook of the research and design process. It records revisions, offering insight into the iterative development that shaped the current implementation of FPS-R. It also briefly repeat the breakthroughs, failures, struggles behind those decisions that will also be recorded in Reflections and Thoughts

🎲 What is FPS-R?

Stateless unpredictability with a structured soul.

FPS-R a domain-agnostic modulation framework, a signal phrasing grammar that expresses a motion archetype I call “Random Move-and-Hold.”
This framework operates across time, space, and cognition when applied in the fields related to intelligence.

🪞 Introduction

FPS-R stands for Frame-Persistent Stateless Randomisation (or 静态律动算法 in Chinese). FPS-R is a grammar and philosophy of motion born from a simple observation: in nature, human interaction and organisational behaviour, randomness is rarely pure noise. It has rhythm, it hesitates, it holds, and it jumps. It feels structured.

This philosophy has been distilled into a set of lightweight, universal mathematical algorithms. These have been further developed into a framework of expressions and functions that are simple, portable, and can be easily adapted into a wide variety of languages (C, Python, VEX, GLSL), running on countless platforms, for an even larger number of applications.

Inspired by these natural behaviours, FPS-R produces structured unpredictability. It describes natural behaviours such as human eye saccades (shifting and darting around), animal foraging, human hesitation, predatory stalking. It mirrors the rhythm of an explorer’s torch in a darkened cave—pausing, twitching, drifting with intent—or the room-clearing maneuver of a soldier’s rifle: moving and holding from one strategic point to another, with every new position disjointed from the last.

I call it the Random Move and Hold.

FPS-R is a manipulator of values over time, sculpting values and temporal behaviour

At its core, FPS-R is defined by three unique strengths:

This framework is not just for motion over time. FPS-R can be applied to any continuous, time-like axis, including spatial coordinates. This means it can be used to sculpt forms and generate geometry, turning its temporal rhythms into physical patterns. Extending further, it can operate in latent and cognitive spaces, contributing to naturalistic AI processes that enable more human-like traits such as focus drift, attention shifts, and even directed, creative “daydreaming.”

FPS-R is not just a motion language—it is a dialect of form and thought.

Ultimately, FPS-R is a collaborator. It can be allowed to roam free for total, wild unpredictability, or it can be given clear boundaries to inject a rich, organic texture into otherwise predictable systems.

🎓 Principles and Philosophy

🧭 Guiding Principle

FPS-R isn’t a single algorithm. It’s a design philosophy for shaping signals. Whether by arithmetic folding or signal quantisation — whether in time or space — the goal is the same: give structure permission to behave.

🎭 Motion Philosophy

FPS-R simulates the unpredictability of hesitation — yet within the same framework, it can just as easily express instinct.

FPS-R algorithms do not switch modes—they sculpt time. Each algorithm is able to express a wide gamut of behaviour, from quick holding twitches and ticks to long and slow deliberate holds that take their own unpredictable time. All these can be achieved by any one of the FPS-R algorithms, with correct settings in their parameters. But the only variable input they really need is just time (in frames).

The values may appear to be random, but when they appear is guided by time (the frame count) itself—producing a rhythm that feels intentional, even without memory. Both values and timing of jumps are totally deterministic.

What emerges is not chaos, but temporal behaviour shaped by structure.

🧒 This rhythm echoes freeze-tag games across cultures — “A-E-I-O-U!” in Singapore, “1, 2, 3 Soleil!” in France, or “Statues” in Greece.
“무궁화 꽃이 피었습니다” in Korea, “木头人” in Chinese cultures,
“Grandmother’s Footsteps” in the UK, “Red Light, Green Light” in the U.S.
Each moment of stillness feels impulsive yet structured —
a hidden choreography of burst and restraint.

🧠 Teaching Note: “No-sim is the best sim.”
In teaching Houdini—which is famed for simulation—I often remind students that building a procedural system without frame-to-frame dependencies is often superior to relying on complex simulations.
The most elegant systems allow each frame to stand alone—yet somehow feel like they remember the past.

📐 Structure and the Illusion of Chaos

FPS-R may appear to drift chaotically, but beneath its phrased irregularity lies a strictly deterministic core. Its behaviour unfolds through modulation operators — composable mathematical expressions like mod() and rand() — applied across domains such as time, space, and input streams. These operators form the expressive substrate of FPS-R’s logic.

What results isn’t raw randomness — it’s structured modulation. Each jump, each hold, each reseed arises from the friction between layered rhythms and offset reseeds, not from entropy. Temporal phrasing emerges where cycles misalign just enough to simulate spontaneity.

In this sense, FPS-R doesn’t simulate behaviour; it orchestrates interference. SM, TM and QS aren’t mere techniques — they are procedural grammar primitives, each governing a different expressive dimension:

Together, these operators form a framework for engineered emergence: where each state transition is mathematically traceable, yet aesthetically untraceable.

No memory is used, and yet the behaviour feels reflective. No stochastic noise is added, and yet it flickers, hesitates, and breathes.

💡 Chaos is not the source — it is the surface. What you see is phrasing. What drives it is structure.

This tension—between definition and drift—is not a flaw. It’s the expressive core of FPS-R.

🗣 A New Grammar:

FPS-R introduces not just a new set of algorithms, but a new lexicon for motion.

“Random Move-and-Hold”

What FPS-R produces is not a filter or a curve — but a compositional structure:
jump → hold → reseed → repeat

graph LR
  A[**Jump**]:::darkBrown --> B[**Hold**]:::darkYellow 
  B --> C[**Reseed**]:::darkRed --> D[**Repeat**]:::red

classDef darkBrown fill:#654321,stroke:#553311,stroke-width:3px,rx:10,ry:10;

classDef darkYellow fill:#B8860B,stroke:#986609,stroke-width:3px,rx:10,ry:10;

classDef darkRed fill:#8B0000,stroke:#5B0000,stroke-width:3px,rx:10,ry:10;

classDef red fill:#FF0000,stroke:#AA0000,stroke-width:3px,rx:10,ry:10;

I call this behaviour Random Move-and-Hold.

It captures the quality of twitch, of deliberation, of pauses that feel like thought.

🎞 Sample Uses of the FPS-R

🧭 FPS-R in Animation

Single Eyeball Look Straight Ahead with Saccades
Eye saccades or darting behaviour in Houdini — Single Eyeball Look Straight Ahead with Saccades🕰️

Double Eyeballs Look at a Moving Box with Layered FPS-R Saccades
Saccades layered on top of object tracking in Houdini — Double Eyeballs Look at a Moving Box with Layered FPS-R Saccades

Eyeball model courtesy of rosytoonz.

🧱 FPS-R in Geometry Generation

⏱️ Visualisation Videos - FPS-R in Action

Here is a collection of visualisations showing how FPS-R can work within larger systems in different contexts to achieve meaningful behaviour. Mostly created in Houdini, posted on YouTube as videos, and as articles on LinkedIn.

LinkedIn Article: FPS-R Test: Rat Movement Demo
YouTube - Rat Demo
'article banner

LinkedIn Article: The Straight Line and the Crooked Path: FPS-R, A New Model for Simulating Reality
YouTube - FPS-R as a Moving Target on Swarm
'article banner

✨ Key Features

🧩 FPS-R in Relationship to a Parent System

FPS-R is modulation without mandate — it shapes expression, but does not command purpose. Left ungoverned, it phrases freely: drifting, pivoting, zigzagging through move-and-hold rhythms that evoke instinct and surprise. Yet in most systems, purpose is present — directing the gesture of a virtual character, a to make a robotic or prosthetic limb feel more natural with micro movements present in humans, or to guide a the focus of an artificial intelligence system.

That’s where FPS-R becomes a collaborator. It doesn’t choose the destination — it inflects the journey.

Think of FPS-R not as a planner, but as a phrasing engine. A heart doesn’t decide where blood flows — but without the beating action, circulation cannot happen. In this analogy, the parent system supplies structure, intent, and context:

💡 Why Do I Need Another Random Stream Generator?

🔍 A Lexicon Gap, Hidden in Plain Sight

FPS-R is not just a random stream generator — it’s a language for articulating the elusive behaviour of random moving and holding.

The fact that this article devotes so much effort to illustrating, contextualizing, and visualizing examples is itself proof of a quiet gap in our expressive vocabulary:
we often observe naturally occurring randomness that feels structured,
yet lack the vocabulary and tools to describe it faithfully.

FPS-R proposes a phrasing architecture to address that void —
not by replacing existing algorithms, but by offering a grammar to sculpt what’s always been there, waiting to be named.

And that is…

🎛️ In the language of math and algorithm:
FPS-R (Frame-Persistent Stateless Randomisation)

🗣️ In our everyday language:
Random Move and Hold

🧠 FPS-R is not a randomiser. It is a universal phrasing primitive—a stateless engine for generating structured surprise, expressive timing, and emergent behavior. It doesn’t simulate reality. It simulates the rhythm of reality’s unfolding.

🧬 The Nature of “Held” Randomness

In both natural and artificial systems, randomness is rarely pure noise —
it often lingers, persists, or evolves in a way that feels intentional.
Whether it’s the shimmer of dappled light, the jitter of analogue machinery,
or the twitchy searching of eye saccades,
we encounter random behaviours that hold their shape or drift over time.

Yet despite how ubiquitous this phenomenon is, most content creation tools are ill-equipped to simulate, emulate and represent it in an intuitively straightforward and lightweight manner.

Replicating this structured unpredictability often requires labour-intensive custom coding or non-intuitive workarounds.

✒️ Metaphor Note: The FPS-R system is like a public pen at the post office.
People come and go: one picks it up, another leaves it askew, sometimes no one touches it for hours.
Each interaction changes its orientation, position, or status—but never with memory.
Yet from a time-lapse sped-up video review, it appears to dance with intention.


Algorithmic Chaos with Poise Stateless Beauty Memoryless, Not Mindless

🧱 Limitations of Conventional Techniques

The Current State of Computation and Calculations

Most computational systems are wired for one principle: efficiency. From shortest-path solvers to rendering pipelines, the default trajectory is straight, steady, and economical. Time, space, value—they’re meant to increment steadily, predictably, toward a desired state. This is the grammar of most algorithms: fewer steps, straighter lines, minimal deviation.

To simulate natural behaviour—pause, drift, delay—we layer complexity upon complexity: recursive pathfinding, Perlin-turbulence on top of sine waves, obstacle-based path deformation, stateful random jumps. These additions mimic real-world unpredictability, but they do so by fighting the system’s fundamental bias toward order. Complexity becomes the price of feeling organic. Results that act and feel natural come at the cost of additional computation on top of straight paths.

FPS-R flips this tendency around. It starts with modulation. It phrases. From the beginning, it wants to jump and drift, it wants to wait and hold, and it wants move forward only to delay and perhaps come back on itself. And yet, paradoxically, it remains stateless, deterministic, lightweight. Rather than accumulating structure to simulate spontaneity, FPS-R embodies and expresses irregularity even as its default form.

And if richer behaviour is required? FPS-R can still be stacked with conventional noise, physics, or reactive inputs—composing layered systems that maintain their phrasing logic even in deeper entanglements.

🧩 FPS-R is a phrasing engine, not a planner. Works with your system. Not to replace it.

When systems attempt to simulate phrased irregularity—deviation, hesitation, unpredictability—they often reach for one of two broad approaches. Both are useful. Both are limited. And neither offers phrasing as its native dialect.

🧊 1. Spatialised Randomness (e.g. Worley Noise & Distance-Based Fields)

These techniques rely on pre-seeded feature points—often jittered grids or hashed distributions—and compute behaviour by measuring distance to these anchors. Worley noise, Voronoi fields, and similar cellular approaches are powerful for generating structured randomness across surfaces.

But their strengths are their constraints:

This makes them excellent for texture, weak for time.

🔁 2. Stateful behavioural Logic (e.g. Timers, Delays, Pauses, Walks)

To generate deviation in motion or behaviour, developers often build state machines or custom update loops that track progress over time. These accumulate logic as layers of interrupts against straight-line behaviour. The goal: produce a sense of intent through delay, error, or noise.

This family is broad. But its footprint is heavy. 🌀 Signal Distortion and Perturbation

⏱ Holding, Delaying, and Interrupting

🛣️ Path Complexity via Indirect Algorithms

🌪️ Contextual Inputs and Reactive Systems

These approaches can work. Many do. But they share four liabilities:

  1. They assume memory
  2. They demand scaffolding
  3. They are rarely portable
  4. They are neither composable nor phrased

⚙️ Why FPS-R is Different

Where most systems create irregularity by layering complexity onto predictable logic, FPS-R begins with modulation. It doesn’t simulate drift—it phrases it. And unlike traditional methods that rely on accumulated state, scaffolded logic, or seeded lookup tables, FPS-R distills expressive behaviour into a single, frame-aware grammar.

Its modulation is clean, deterministic, and portable—expressing structured spontaneity without state.

Key advantages include:

🪞 Most modulation systems simulate intent by scaffolding state. FPS-R phrases intent by design—and does so without memory.

That’s why FPS-R can:

The world of simulation builds structure to allow drift. FPS-R starts in drift—and phrases structure into it.

🧩 Deterministic Complexity Where intricate behaviour emerges from repeatable rules, not randomness.

❓ Why Not Just Use State? (And Why It Matters)

To understand the power of FPS-R, it’s helpful to first understand the two fundamental ways a system can operate: with memory (stateful) or without it (stateless).

Before FPS-R, achieving the “random-move-and-hold” behaviour often required building custom, stateful logic. This typically involved tracking timers, setting flags, or using counters to decide when a value should hold and when it should jump. While effective for simple cases, these solutions are often brittle and context-specific. They create a patchwork of logic that is difficult to maintain, port to other systems, or scale in complexity.

This state-dependent approach has significant limitations, especially in modern applications:

FPS-R’s stateless design directly solves these problems by providing instant, random access to any point in time or space, ensuring predictable results and compatibility with modern, parallel architectures.

The “Shell vs. Soul” Analogy: Why Stateless is Powerful

In complex simulations—from visual effects to scientific modeling—a fundamental choice exists between storing the results of a simulation and storing the rules that generate it. This choice can be understood through the “shell vs. soul” analogy, which highlights a critical difference in how information is represented, scaled, and explored.

The Cached Simulation (The Shell)

This is the brute-force approach, common in VFX pipelines and heavy scientific simulations. To ensure a complex, computationally expensive result is repeatable and can be played back quickly, the final state of every element at every point in time is calculated once and saved to disk. This is known as caching.

This is “saving the shell.”

The Procedural Logic (The Soul)

This is the stateless, elegant approach embodied by FPS-R. Instead of storing the final results, you store the compact, deterministic rules that can generate those results on demand.

This is “saving the soul.”

The Freedom to Explore: Vector vs. Raster

The most profound advantage of the procedural “soul” over the cached “shell” is the freedom of inquiry. This is best understood through the analogy of vector vs. raster graphics.

A Real-World Example: The 200GB Wave Simulation

This isn’t a theoretical problem. This was an actual project that I was involved in. In a real-world visualisation project involving a wave pool simulation, elegant physics formulas from MATLAB (the “soul”) had to be exported into Houdini (3D content creation software) to visualise the simulated water surface. The only way to transfer the data was to make it explicit, resulting in dense CSV files containing pressure, density, and position for countless points within the water volume that filled the representation of a pool.

The result was a dimensionality explosion: each frame of the simulation became a 200MB file. A decision to add just two more decimal places of precision would have added many more gigabytes to the final storage cost. The elegant “soul” was lost, replaced by a massive, inflexible “shell.”

This is the exact problem that a procedural, stateless framework like FPS-R is designed to prevent. It preserves the “soul” so you are never trapped by the limitations of the “shell.”

Transcending Traditional State: The Deeper Advantages of FPS-R

FPS-R doesn’t replace stateful methods—it transcends them.

Beyond solving the problems of storage and scalability, the stateless nature of FPS-R unlocks fundamental architectural advantages that traditional stateful logic cannot offer. It addresses challenges that arise when moving from simple scripts to complex, multi-platform, and collaborative systems.

🧳 State Doesn’t Travel: Portability Across Modern Architectures

A stateful hold-and-jump loop works well in a simple script, but it relies on persistent memory that is local to its process. This logic breaks down in modern, highly parallel computing environments where state does not persist between calculations.

FPS-R, being stateless by design, thrives in these environments. It runs wherever a pure function can, making it natively compatible with the parallel architectures that power modern graphics, machine learning, and large-scale simulation.

🧠 The Glass Box: Perfect Traceability and Debugging

A stateful system is often a “black box.” Once a simulation has run, its history is a blur of overwritten variables. If a crash or an unexpected behaviour occurs at frame 58,200, it’s nearly impossible to perform a forensic analysis to understand why. The causal chain is lost.

FPS-R, by contrast, is a “glass box.”

Every value it produces is derived solely from visible, reproducible inputs—frame, seed, parameters—not from hidden buffers or accumulated memory. There is no fog of history. Every phrased moment can be reconstructed, explained, and replayed from a single formula. FPS-R doesn’t just generate a result; it provides a complete, auditable trail of how that result came to be.

🌌 Domain Agnosticism: From Time to Space and Beyond

Stateful loops are inherently temporal; they are built around a clock that ticks from one frame to the next. This makes them difficult to apply to other domains. How do you use a time-based loop to modulate a static 3D surface, a character’s gaze velocity, or the weights in a neural network? The logic doesn’t translate.

Because FPS-R is stateless, its input is not fundamentally “time”—it is simply a coordinate. This coordinate can be a frame number, a 3D position vector, a UV coordinate, or any other scalar or vector stream. This makes FPS-R truly domain-agnostic, allowing its rich phrasing behaviours to be applied across any continuous system.

🧭 Elegant Composability: Building with Capsules

Integrating multiple stateful modulators is notoriously brittle. Their internal states can interfere with each other in unpredictable ways, creating a fragile and hard-to-debug system.

FPS-R functions, being pure and stateless, compose cleanly and safely. You can layer them, chain them, or use one to drive the parameters of another, and the resulting system remains fully deterministic and predictable. This allows for the creation of modular “capsules”—pre-packaged, named behaviours (hesitate, flicker, drift) that can be stacked and combined to create incredibly complex phrasing with guaranteed stability.

(Note: Capsules have yet to be implemented at this time.)

Traditional state holds behaviour in place. FPS-R lets behaviour move—across systems, across domains, across minds.

📊 Explore the Algorithm’s Fingerprint

The FPS-R algorithms produce a unique rhythmic “fingerprint” over time. The animated preview below shows the scrollable timeline graph from the included Jupyter Notebook, which allows you to explore this behaviour visually.

Jupyter FPS-R Notebook Interactive Timeline

To try it yourself, you can explore the interactive timeline in a Jupyter notebook on nbviewer The interactive scrolling graphs are the last 3 cells at the end of the notebook.

Note: Jupyter notebooks render only as static content on GitHub’s web viewer. Interactive scrolling graphs for SM and QS will not show up. If you want to play around with the parameters and drive a different resulting curve, and inspect the scrolling graphs, please feel free to download the notebook and execute it on your local machine runnning Jupyter notebook on a Python 3.x kernel with the relevant dependencies (Pandas and Matplotlib). FPS-R-SM Timeline Graph Preview FPS-R: Stacked Modulo Timeline Graph Preview FPS-R-TM Timeline Graph Preview FPS-R: Toggled Modulo Timeline Graph Preview FPS-R Timeline Graph Preview FPS-R: Quantised Switching Timeline Graph Preview

Interactive FPS-R WebGL Visualizer

A live, interactive demo of the FPS-R algorithms is available.

Click here to launch the visualizer img

🧬 Flavours of FPS-R

FPS-R comprises three distinct mathematical algorithms — each offering a stateless, deterministic approach to phrased modulation:

These form the primary modulation operators within the FPS-R framework, usable independently or composable into parallel blends and chained sequences. Together, they shape the expressive grammar of randomised move-and-hold behaviour — tuned, layered, and always reproducible.

🌀 Stacked Modulo (SM) or 叠模机制

The original FPS-R operator. SM constructs motion through layered modulus functions with shifting offsets — producing transitions that feel spontaneous, yet arise from strict deterministic interference.

The signature feel of the SM algorithm comes from its “stacked” or nested rhythmic structure. It’s an interference pattern created by two different clocks running at the same time.

SM gives the most natural and organic expression of the Random Move and Hold phenomenon.

SM Features:

🔁 Toggled Modulo (TM) or 切模机制

TM modulates hold durations by toggling between two predefined time periods, producing rhythmic variation without introducing random noise. It retains the stateless determinism of FPS-R, but with explicit and controllable alternation — a midpoint between SM’s nested unpredictability and QS’s stream swapping.

Where SM reshapes time using internal modulation and QS switches outputs across streams, TM adjusts duration logic itself — controlling the pace of phrased persistence through toggled timing.

Switching between the two configurable fixed-value cycle durations, while still organically and deterministically “unpredictable”, TM gives the most consistent and structured output pacing compared to SM and QS. There is a sense of mechanical stability underpinning the structure of unpredictability.

TM Features:

✴ Quantised Switching (QS) or 量跃机制

Quantised Switching (QS) generates two independently modulated signal streams from sine-based functions, each quantised to a randomly selected level within a defined range. These quantisation levels are refreshed deterministically on separate timing cycles, with configurable durations and offsets per stream. A switching mechanism alternates between the streams, and the compound interplay between quantisation, reseed cycles, and switching cadence drives the final output.

This behaviour is inherently more volatile than SM’s and TM’s, as a change in any of its layered rhythms can trigger a jump in the final output.

QS is the most “lively” and “active” of the FPS-R algorithms. It only holds its random value when all the individual time cycles fall within their modulo periods. QS wants to glitch and jump.

QS Features:

🏙 Spatial Extension: From Time to Space

FPS-R doesn’t just animate motion—it builds form. By substituting temporal input ($F, @Frame) with spatial coordinates (x, y, uv, position), FPS-R algorithms become surface-shaping operators: capable of driving heightfields, silhouette generation, panel logic, and procedural texturing. Each algorithm expresses its phrased modulation logic across spatial domains—ideal for modeling, tiling, and stylised segmentation.

🧬 FPS-R in the Spatial Context

🪡 Topology Wrapping and Surface Application

FPS-R isn’t limited to flat grids or linear mappings. When evaluated over spatial coordinates like normals, UV shells, or surface position vectors, its stateless and deterministic nature makes it compatible with complex topology.

FPS-R’s phrased logic transfers smoothly to surface behavior—enabling modulation on curved geometry without relying on periodic tiling. Edge blending, mirroring, or domain conditioning may be used for controlled repetition where needed.


Procedural Form Signal-as-Structure

🌀 Stacked Modulo in Space

SM generates nested interference from layered clocks—ideal for architectural repetition, facade tiling, and rhythmic modulation in detail density.

🔁 Toggled Modulo in Space

TM introduces structured rhythm via toggled durations—useful for spatial alternation of components, extrusion heights, or element spacing.

✴ Quantised Switching in Space

QS functions as a stream selector across space—switching between signal banks, texture generators, or quantisation modes based on coordinate rhythm.

“Just as QS modulates time by switching behavioural regimes, it can modulate space by switching surface logic—turning texture banks or heightmap engines on and off with structured unpredictability.”

🧠 Nested Modulation: Using FPS-R to Drive FPS-R

FPS-R algorithms can be used as inputs to other FPS-R functions, creating layered modulation—where one phrasing signal controls or reshapes another. This allows for multi-level behaviour in a single system, without needing external state or complex dependency chains.

Common uses include:

This nesting doesn’t break statelessness—it preserves it. Each output is still deterministic, but the control logic becomes more expressive. Instead of flat randomness, you get structured variation driven entirely by compact expression layers.

Fractal Assembly

🧪 Modulating Introspection

FPS-R streams can be used not only for output generation, but for self-monitoring and diagnostic feedback. This means a modulation signal can expose internal timing, phrasing decisions, or regime shifts—making it useful for adaptation, analysis, or visualization.

Possible applications:

Example: In a cognitive system, one FPS-R stream modulates visible behavior, while another monitors phrasing structure—revealing when a modulation shift occurs, how long holds persist, or when a behavioural loop emerges. This can produce introspection signals that explain the why behind modulation, not just the what.

Recursive Modulation Introspective Flux

📈 Meta-Signal Analysis: FPS-R as Observer and Instrument

FPS-R doesn’t just generate phrased signals — it also makes it possible to study and interpret them. By turning phrased outputs into shapes, graphs, or surface features, FPS-R exposes the structure of its own modulation patterns. This helps users understand timing, variation, and layered behaviour.

Key patterns that become visible include:

Because FPS-R is stateless and deterministic, these outputs are consistent every time. That makes them ideal for debugging, classification, or teaching — especially when visual feedback reveals why a pattern behaves the way it does.

When a phrasing signal is plotted across time or space, it becomes not just output — but insight. A rhythm that can be analysed, reused, or named.

🪞 Common Uses of Signal Mapping

Signal mapping makes FPS-R not only a generator of behaviour, but also a way to describe and reuse it.

🧠 The signal itself becomes a record — encoding phrasing behaviour through deterministic structure, not saved state.

🧭 Application Paradigms

FPS-R is a modulation engine that adds phrasing to behavior. It doesn’t make decisions — it shapes how those decisions play out.

In larger systems that define intent — whether it’s to look, move, signal, or wait — FPS-R handles the expressive timing. Planners, inference engines, and control logic decide what should happen and why. FPS-R determines how it happens.

Its key contribution is behavioural unfolding: stateless, deterministic phrasing that feels intentional without introducing randomness. It doesn’t generate chaos or improvise — it adds structure, rhythm, and nuance to existing plans.

FPS-R doesn’t lead the system. It makes the output feel deliberate.

Rather than organizing FPS-R by industries like animation, robotics, or interaction design, we can describe its expressive range through three integration patterns. Each highlights a different way phrasing can support a system’s goals.

FPS-R doesn’t replace decision-making logic — it works alongside it. When a larger system defines what to do, FPS-R defines how that action unfolds over time or space.

These three paradigms show how phrasing can:

Where a system brings purpose, FPS-R adds timing, rhythm, and modulation — making even simple decisions feel intentional and expressive.

These paradigms aren’t just use cases. They reflect design choices in how phrasing can serve clarity, resilience, or exploration.

🎨 Part I — Generative Expression & Organic Simulation

FPS-R as a composer of lifelike timing and motion.

This paradigm focuses on using FPS-R to make synthetic systems feel more natural. Instead of looping animations or hardcoded delays, FPS-R produces patterns that change over time without chaos. The result is behaviour that appears intentional but isn’t repetitive.

Systems that benefit from this include those dealing with attention, motion, feedback, or signaling—especially when variation helps maintain realism or avoid mechanical output

In these cases, phrasing isn’t decoration — it’s what gives behaviour its expressiveness and timing.

🕶️ AR/VR and Human-Centered Interaction

FPS-R helps make avatars and user interfaces behave more naturally by adding small, structured timing variations to gaze, motion, and feedback. These phrasing patterns simulate attention drift, subtle delays, and non-repetitive reactions—enhancing realism and immersion.

It’s especially useful in accessibility testing, human modeling, and mixed-reality environments where predictable but expressive behaviour improves the sense of presence.

🤖 Robotics and Embodied Systems

In robotics, FPS-R creates motion patterns that feel intentional but don’t repeat. It can drive idle movement, small gestures, or gaze shifts that show awareness, hesitation, or readiness—without complex logic or stored state.

This improves human-robot interaction, supports adaptive control, and helps machines signal responsiveness in a way that feels believable and readable.

🧤 Wearables and Assistive Technologies

FPS-R adds subtle timing to prosthetics, exosuits, and haptic systems—making automated motion feel less mechanical and more human. By introducing quiet variation in phrasing, it improves the sense of embodiment for users and creates more intuitive feedback for others interacting with the device.

This modulation helps restore dignity through expressive movement, improves social acceptance of assistive tools, and supports personalization without increasing system complexity.

🧬 Biofeedback and Adaptive Expression

FPS-R translates internal signals—like heart rate or breath—into phrased output that guides or calms without looping or erratic changes. Whether driving light patterns, tactile feedback, or ambient cues, its modulation reflects physiological shifts in a subtle and readable way.

Because phrasing evolves without needing historical data, feedback feels responsive but not reactive—useful for wellness, meditation, and supportive interfaces.

🛰 Swarms, Drones, and Spatial Coverage Systems

In distributed systems, FPS-R avoids rigid repetition by modulating timing in movement, signal updates, or positional changes. Each agent behaves deterministically but with unique phrasing—supporting expressive decentralization and predictable diversity.

This makes swarm behavior more lifelike and adaptive, without the need for centralized communication or memory-sharing across agents.

💡 Embedded Systems and Ambient Interfaces

For low-resource platforms like microcontrollers or kinetic installations, FPS-R offers expressive modulation with minimal footprint. It enables timing logic that feels intentional—without non-deterministic random generators or the overheads of memory buffers or stateful computation logic.

Use cases include motor control, reactive lighting, or ambient feedback loops where phrased motion improves perceived intelligence and user engagement.

🎼 Domains of Application in Audio and Composition

FPS-R introduces phrasing logic into sound design and generative music systems—allowing rhythm, texture, and variation to emerge deterministically. Instead of looping envelopes or stochastic triggers, phrased modulation lets sonic elements move with intent across beats and transitions.

It can drive modulation depth, switch synthesis modes, or reshape filter timing—creating sounds that drift, glitch, pulse, or pause in structured but unpredictable ways. Useful for both micro-level shaping and macro-level pattern composition.

🧪 Part II — Systemic Resilience & Analysis

FPS-R as a modulation layer for testing, simulation, and system diagnostics.

This paradigm uses FPS-R to probe system reliability and surface hidden weaknesses. Its phrasing introduces variation that looks unpredictable, but is fully reproducible—useful for stress testing, edge case discovery, and behavioural simulation.

FPS-R doesn’t mimic chaos—it replaces it with structured modulation. That makes failure points easier to find, replay, and analyze.

In these cases, phrasing isn’t aesthetic — it’s functional and diagnostic.

🛡️ Cybersecurity and Adversarial Simulation

FPS-R generates procedural threat patterns that are stateless and replayable—ideal for training, penetration testing, and scenario simulation. Modulation can reveal brittle timing, unexpected event sequences, or exploitable behaviours without relying on external randomness.

It supports parity between red and blue teams, simulation values can be logged and captured in capsules (captured snippets of FPS-R logging, capturing settings and frame numbers enabling deterministic repeatable replays and analysis). These will enable breach replay, and helps test system response under structured pressure.

💸 Financial Systems and Economic Simulation

Use phrased modulation to model volatility, market timing shifts, or policy effects—all without historical datasets. FPS-R creates deterministic scenarios that simulate instability, helping stress-test algorithms and observe long-term behaviour under shifting conditions.

This is useful for testing risk strategies, resilience logic, and regulatory response.

🧪 Software Testing and Fuzzing

FPS-R acts as a phrased input generator, simulating user interaction or API calls with changing cadence, timing, and payloads. Unlike true randomness, it allows full replay and analysis—making it easier to isolate bugs, discover edge cases, or trace timing violations.

Useful for testing sequence-dependent logic, state transitions, and modular fault tolerance.

🧵 Systems-Level Protocol & Infrastructure Simulation

Apply FPS-R to modulate protocol timing, system churn, or distributed coordination patterns. It can reproduce structured network degradation, simulate infrastructure failure, or reveal limits of resilience in layered systems.

Because it’s stateless and compact, phrased modulation fits into low-level simulations without requiring overhead or state tracking.

🧠 Part III — Generative Scenario Planning & Speculative Design

FPS-R as phrasing logic for emergent futures and cognitive drift.

This paradigm uses FPS-R to explore how systems behave when context shifts, goals change, or multiple agents interact under uncertainty. Instead of just simulating motion or pressure, it helps model timing logic within complex decision environments—where phrasing affects escalation, attention, or strategy.

FPS-R brings deterministic modulation to forecasting, planning, and design exploration. It supports scenario building, timing asymmetry, and emergent behaviour—all without needing memory or external noise. That makes it especially useful for designing what could happen next, under varied but controlled conditions.

Here, phrasing is a lens—not just for describing action, but for discovering possibility.

⚔️ Game Theory, Politics, and Strategic Modeling

FPS-R adds timing variation to simulations of strategy, competition, and negotiation. It can drive delayed responses, sudden shifts, or staggered transitions between states—making agent behavior feel more tactical and less scripted.

Useful for modeling escalation, timing asymmetry, or unpredictable decision pacing between adversaries, all while keeping outputs deterministic and replayable.

🧭 Process & Contingency Simulation

FPS-R helps simulate how systems respond under drift, delay, or pressure. It modulates task timing, failure onset, or recovery pacing—useful for testing operations, logistics, or procedural reliability.

Ideal for exploring how structured randomness affects workflow resilience, especially when planning for uncertain scenarios or stress conditions.

🧠 Cognitive Modeling & Generative Thought

FPS-R as a timing engine for synthetic cognition

At its most advanced use, FPS-R isn’t just a modulation engine—it becomes a framework for modeling how systems think. In this speculative but increasingly real application space, FPS-R modulates not what is thought, but how thought unfolds. It shapes attention flow, deliberation rhythm, and conceptual transitions—providing timing logic for cognition.

Thought as Temporal Behaviour

In systems like large language models, FPS-R can act as a temporal pacing layer—modulating attention as it moves through ideas.

This doesn’t change the model’s knowledge. It changes how knowledge is surfaced—giving timing and texture to idea flow. Cognition becomes not just a sequence of outputs, but a shaped journey through context.

Structured Ambiguity Without Memory

In fuzzy logic or threshold-driven systems, FPS-R enables procedural hesitation. Instead of using saved state or reprogramming rules, the system adapts through phrasing:

This modulation offers ambiguity without chaos—and adaptability without overhead.

Dialogue as Timing Logic

In conversational agents, FPS-R shapes the rhythm of interaction. It manages when a system pauses, returns to earlier points, or pivots to new topics:

Importantly, this coherence doesn’t require memory tracking—phrasing alone can create continuity, making conversations feel more natural and intentional.

Latent Drift and Composed Cognition

FPS-R can also guide how synthetic systems move through latent space. Between a starting concept and a goal, FPS-R produces a modulated trajectory rather than a straight interpolation. That means:

This enables path-dependent creativity—where the shape of traversal influences the outcome. Expression is shaped not just by content, but by how the system arrives there.

Tunable Personality and Emergent Creativity

By embedding phrasing logic into cognitive systems, designers can tune behaviour capsules:

Systems start to behave less like completion engines and more like thoughtful partners—modulating not just meaning, but the style of its emergence.

FPS-R enables systems to show hesitation, curiosity, or drift—not through changing what they think, but how their thoughts emerge.

Once a behaviour is captured and phrased, it’s no longer just an isolated motion—it becomes a reusable signal of intent. FPS-R transforms cognitive behaviour into a modulatable reality: accessible, repeatable, and expressive.

You’re not just animating thought. You’re anchoring cognition to timing—giving systems a grammar for thinking with rhythm.

🕰️ Exploring Plausible Past and Future in Observable Phenomena

Using phrasing logic to reconstruct behaviour over time

FPS-R isn’t just for generating behaviour—it can also be used to analyze and extend real-world motion or events. Because it’s deterministic and parameterized, FPS-R provides a consistent way to describe how something unfolded, and how it might continue. This makes it especially powerful for fitting observed behaviour to structured phrasing and projecting it forward or backward.

How the Matching Works

When a researcher notices a specific rhythm or motion—like a twitch, pulse, or drift—they can try to match it to an FPS-R signal. This means adjusting phrasing parameters until the modulation shape aligns with the observed behaviour.

Matching methods include:

When multiple phrasing traits align—timing cadence, modulation shape, drift/hold balance—confidence increases. A short match might be coincidence. A long one often reveals expressive resonance between system and signal.

What This Unlocks

Once a match is made, FPS-R becomes a generative analog of the behaviour. It allows for procedural reconstruction in both time directions:

This produces what’s called a temporal grammar—a phrasing scaffold that models not just events, but their expressive trajectory.

It Goes Beyond Motion

This approach can be used with any observable pattern that shows phrased character:

FPS-R isn’t guessing the future. It’s generating structured possibilities—using phrasing to define what’s plausible, not what’s random.

Understanding System Readiness

By matching phrasing to systems—whether physical, behavioral, or procedural—we gain insight into their ability to handle state changes. Studying both extrapolated past and future phrasing offers visibility into potential responses, risk, or expressive continuity.

📽️ Implications

Phrasing doesn’t just animate—it becomes a way to read and extend time itself, with structure instead of random memory or speculation.

📡 A Real-Time Scenario

Imagine an AI trained to extract motion—such as the horizontal flicker of a candle—and fit it to an FPS-R phrasing model. In real time, it could output:

The result isn’t just playback—it’s a procedural timeline built from modulation logic.

And because FPS-R is fully deterministic, these outputs are reproducible, analyzable, and portable. The phrasing curve becomes a tool for studying the behavior’s shape, not just observing it.

FPS-R turns events into modulation fields—spaces where timing becomes explanation, and phrasing becomes structure.

🌐 Closing Thoughts on Usage

The examples above trace a constellation, not a boundary. As FPS-R pulses into prosthetics, haptic grammars, biofeedback loops, vision rhythms, and musical phrasing, its grammar still remains unfinished.

It doesn’t simulate intelligence—it expresses modulation. Not a model of thought, but a choreography of response.

Whether nested in a footstep, a glance, a circuit, or a breath, FPS-R speaks where behaviour meets texture—and every new context awaits translation.

So take it. Reshape it. Let it hesitate where no behaviour has paused before.

🚀 To modulate boldly, where no signal has modulated before.

🔩 How FPS-R Works (A Gentle Primer)

At its heart, FPS-R is a rhythm machine—generating unpredictable but structured signals over time or space.
It doesn’t store memory. It doesn’t know what came before.
Yet what emerges feels like hesitation, twitch, or drift.

You tell FPS-R which frame (or position) it’s in, and it sculpts a value based on simple math:
modular rhythms, seeded randomness, layered transitions.
From that alone, it creates the illusion of thought—without ever thinking.

FPS-R unfolds through three intertwined methods.
Each one offers a unique lens—structured pulses that unlock different facets of unpredictability.

Here’s the basic idea:

🎼 Stacked Modulo (SM)

Like overlapping metronomes—each frame lands within multiple rhythm layers, each with its own time signature.
Some tick slowly, some twitch fast. Where their cycles overlap, a value is held… until one metronome hits the end of its measure—and triggers a jump.

When does the signal hold?

When does the signal jump?

✴️ Quantised Switching (QS)

In its most basic form, Quantised Switching is a signal selector. Two signals (typically sine waves) are generated—each with its own time signature, much like SM’s layered rhythms.
But instead of flowing smoothly, each signal is sliced into discrete steps. Another rhythm governs the selector itself.
When the selector reaches the end of its measure, a jump occurs—triggering a probable switch to the alternate signal (though it may stay).
Separately, if the currently selected signal jumps between steps, a jump in the final value also happens.

When does the signal hold?

When does the signal jump?

These layered, deterministic jumps—both in selection and value—offer stylistic glitch, rhythmic flicker, and behavioural unpredictability.

Each method is stateless. Each moment is decided without memory.
And yet, the result feels strangely alive.

👉 Want to unpack the full mechanism, token by token? Dive into the technical breakdown here:
Read FPSR_Tech.md →

🌐 Closing: An Invitation

Ultimately, FPS-R does not claim to be a perfect mirror of reality. It is a dim reflection, a lens crafted to point towards the larger beauty of imperfection and unpredictability we see in the natural world.

It is an invitation to look closer, to appreciate the nuance in every hesitation and jump, and to come and discover more for yourself.

🚧 Current Status

FPS-R is under active development and currently private during cleanup. Planned improvements:

⚠️Future Developments

Capsules

What are capsules?

Capsules parameterised modulation profiles.

Capsules are parameterised modulation profiles that record phrasing behaviour over time. Each capsule encapsulates both:

This pairing allows users to reproduce expressive behaviour deterministically — not as an approximation, but as a perfect playback of phrased motion within its original modulation context.

At their core, capsules store two categories of data:

  1. Time-Based Performance
    • Start and end frame of the modulation clip
    • Value at every frame across the timeline
  2. Parameter Configuration
    • Algorithmic choices and tunings
    • Modulation settings and domain inputs

A collection of capsules forms a library of expressive phrasing: Each clip represents a distinct behaviour profile — some intentional, some discovered through emergent “happy accidents.” Over time, these capsules serve not just as utility, but as a creative archive: motion phrases with poetic structure, reusable across domains.

Capsules exist because FPS-R is fully deterministic and stateless. Every phrased drift can be traced, stored, and recalled — performance becomes grammar.

Why do We Need Capsules?

Given the unpredictable and continuous nature of FPS-R’s performances, it is easy to get lost with endlessly tweaking seed values and parameters without being able to get the exact performance we want. Capsules serve as a collection of “moments”. Giving descriptive names to the observed behaviour and performance characteristics of captured clips allow us to store and exactly reproduce these results when the context calls for it.

What Can We Do With Capsules?

Capsulses provide a way to document and categorise various performances for replayability, so we can reproduce the exact performance with the same input parameters.

🗒️ Additional Development Notes

🧠 FPSR Thoughts

(click here)
This is a the thoughts about the tools I have created.

📔 Development Reflections

(click here)
This is the chronological diary of the events leading to the discovery of these methods and techniques.

🤝 Contributions

If you’re into procedural chaos, analogue aesthetics, or the poetry of entropy—your thoughts are welcome once it returns to public life.

This site is open source. Improve this page.