Glyphfall
A browser puzzle that combines spatial placement with meaning: form words from falling letters, or arrange adjacent digits into runs totaling ten.
What it is
The challenge is to think about both the shape and its contents. Filling a row is not enough: the placement has to make a word or a sum. Clearing cells collapses the board and can trigger another match.
Both modes work with touch or a keyboard. Best scores stay on the device, and anonymous playtest telemetry is separate from those personal records.
The loop it has to make believable
- 01
Place and rotate letter pieces to form familiar words across, down, along diagonals, or around a square; a live hint shows one possible word.
- 02
Switch to Math and build horizontal or vertical runs of three to five digits totaling ten, using the same spatial engine.
How it’s built
Rendering, run lifecycle, and game rules are separate modules. Words and Math share collision, rotation, queueing, hold, and gravity, so the semantic rules can evolve without forking the engine.
The API accepts token-scoped, idempotent session writes. PostgreSQL owns durable constraints; bounded client queues and retries prevent slow or unavailable telemetry from interrupting play.
Architecture
- Interaction
- Phaser scene with keyboard and touch input
- Rules
- Framework-independent engine for collision, hold, locking, clearing, collapse, and cascades; pluggable Words and Math modes
- Lifecycle
- A separate RunController owns run start, completion, local records, and reporting
- Telemetry
- Bounded browser batches, timeouts, exponential backoff, token-scoped writes, and PostgreSQL deduplication
What has to hold up
- Movement and rendering continue through API failures; sync status makes unsent runs visible.
- Database integration tests exercise concurrent completion, retries, sequence conflicts, and schema bounds that an in-memory test double can miss.
What remains open
Human playtesting has not established whether the word hints, overlap scoring, or difficulty curve feel satisfying. Simulations help expose failure pressure and easy strategies, but they cannot establish player enjoyment.
There are no accounts, multiplayer, or shared leaderboards. Local benchmarks are synthetic evidence, not production latency guarantees.
Proof
VerifyRepository, checks, stack, status
- 01
Follow the README to launch the browser and API, then try both Words and Math.
- 02
Inspect GameEngine, RunController, and the mode-specific rules and tests.
- 03
Run the documented tests and build; use the PostgreSQL test path to check durable ingestion behavior.
- 04
Read PRODUCT.md and the README limitations before interpreting simulations as evidence of game quality.
- Role
- Game design, engine, interface, backend, and verification
- Scope
- Desktop and mobile browser game with anonymous playtest telemetry
- Proof
- Engine and run-controller tests, PostgreSQL integration checks, simulations, architecture, and runbook
- Stack
- TypeScript, Phaser, Vite, Fastify, PostgreSQL, Vitest, Docker
- Modes
- Words + Math
- Engine
- Shared deterministic rules
- Telemetry
- Retry-safe ingestion
- Scores
- Stored on device