CORE01
Deterministic Rust core
Simulation logic is written so identical inputs and state reproduce identical results.
NoteField
A modern, deterministic Rust-based 2D rhythm game where timing is exact and every run is reproducible.
prototype Rust · deterministic core · 2D rhythm field · reproducible play
PB-11 prototype
SYS/CHAIN 04 CHANNELS PALOMA BB
- Language
- Rust
- Format
- 2D rhythm
- Core guarantee
- Determinism
- Status
- Prototype
01
02
03
04
What is real today
A rhythm game whose clock does not lie.
NoteField is a modern 2D rhythm game built in Rust around a deterministic core. Judgement derives from exact timing rather than frame luck, so the same inputs on the same chart produce the same play, every time.
Determinism is treated as the feature, not a constraint. The field renders clean 2D lanes and notes while the timing layer stays exact, which keeps replays meaningful, practice honest and difficulty tuning a measurement instead of a feeling.
The project is a prototype. Its public description covers the deterministic foundation and the play field; features are claimed when they exist, not before.
System shape
One exact clock drives the whole field.
Notes, judgement and scoring all read from the same deterministic source of time.
TIME02
Exact timing
Note positions and judgements derive from the game clock instead of frame-adjacent approximation.
FIELD03
2D play field
Lanes, notes and feedback render as a clean, readable 2D presentation.
PLAY04
Reproducible play
Runs are repeatable, which makes practice, tuning and comparison trustworthy.
Current evidence
The prototype proves the foundation before the features.
What exists today is small on purpose and exact where it counts.
01
Core
Deterministic
Identical runs stay identical — the base a rhythm game deserves.
02
Stack
Rust
The whole game is built in Rust rather than scripted around an engine.
03
Field
2D presentation
The play surface stays legible instead of hiding timing behind effects.
04
Status
Prototype
The scope of claims matches the scope of the build.
Operating principles
Constraints that keep the work honest.
Determinism first
Exact timing outranks spectacle.
Timing is gameplay
The clock is the mechanic, not an implementation detail.
Rust foundation
The core language carries the guarantees.
Modern, not heavy
Clean 2D presentation without dragging a generic engine along.
Connected work