A Tetris game inspired by Tetris Effect, but playing any playlist you like: your own music folder or a YouTube playlist. Each song is analysed ahead of time (tempo, key, structure: intro, verse, build, chorus, drop...) and the game stages it: pieces fall on the beat, the pace follows the song's energy, and a procedurally generated 3D scene evolves with every section. Built in C++ / OpenGL 3.3.

Nine scenes generated by the game. Every song, and every run, gets its own scene.

Prebuilt packages for Linux, macOS (Intel and Apple Silicon) and Windows are on PyPI.

Run it directly with uv, without installing:

uvx zentris "https://www.youtube.com/playlist?list=PLWHPu2N_Gb2lbZ8-7sYKSEbDlb3UiAVye"
uvx zentris ~/Music
uvx --from zentris zenscope ~/Music      # the analysis viewer

Or install it with pipx (or uv tool install zentris):

pipx install zentris
zentris "https://www.youtube.com/playlist?list=PLWHPu2N_Gb2lbZ8-7sYKSEbDlb3UiAVye"
zentris ~/Music             # with no argument it plays ./audio, or ~/Music
zenscope ~/Music            # the analysis viewer

Quote YouTube URLs: & is special in the shell. The package brings yt-dlp and an ffmpeg build for YouTube playlists; YouTube also needs a JavaScript runtime (Deno or Node.js) on your system.

Dependencies (Debian/Ubuntu): sudo apt install cmake g++ libglfw3-dev libglew-dev (miniaudio and stb are vendored in third_party/).

cmake -S . -B build && cmake --build build -j
./build/zentris                 # plays every .mp3/.wav/.flac in ./audio, in order (--shuffle for random)
./build/zentris song.mp3 ~/Music --fullscreen

YouTube playlists (or single videos) work too, through yt-dlp (install it with pipx install "yt-dlp[default]"; YouTube also needs a JavaScript runtime such as Deno or Node.js, and Node.js is picked up automatically). Songs are downloaded when queued and cached as MP3 in ~/.cache/zentris/youtube/. Downloading from YouTube is against its terms of service: personal use only.

./build/zentris "https://www.youtube.com/playlist?list=PLWHPu2N_Gb2lbZ8-7sYKSEbDlb3UiAVye"   # quote it: & is special in the shell
./build/zenscope "https://www.youtube.com/watch?v=..."

Other options: --shuffle (random song order; default is in order: folders alphabetically, playlists in their order), --seed N (repeat a scene), --autoplay, --mute, --size WxH, --shots PREFIX N (renders N screenshots of different scenes and exits), --phase-shots PREFIX (one screenshot per scene level of a song).

./build/zenscope [songs or folders...] plays a song and shows the analysis that drives the game:

• a phase timebar with the scene levels (calm / mid / peak) and where the scene changes happen
• the detected structure: intro, verse, build, chorus, drop, break, outro, with similar parts grouped
• pulse zones, a 16-band spectrum, loudness, intensity and onsets, and bar lines
• a live readout of the current section and the game's density/speed/glow profile, with the beat in the bar
• a zoomed detail view with the beat grid

Space plays/pauses, Left/Right seek 5 s, Up/Down zoom the detail view, N/P change song, click to seek. The game and zenscope share the same analysis and song plan code (src/songplan.*), so what you see is what the game uses.

Keyboard and gamepad both work at the same time. A gamepad is detected at startup and on hot-plug, and the on-screen hints follow whichever device you used last. Controllers are recognised through the bundled SDL_GameControllerDB (third_party/gamecontrollerdb.txt; extra mappings can be given in SDL_GAMECONTROLLERCONFIG). A controller missing from it still works with a generic layout.

Each song is decoded and analyzed in the background (under 1 s):

• Tempo and beat grid: gravity steps land on the beat, at 1 row every 2 beats, every beat, or every half beat, depending on the song's energy at that moment.
• Levels: one level per 20 lines, up to a plateau at level 20. Each level speeds up the beat-locked gravity (at the plateau: 5, 10 or 16 rows per beat for calm, mid and peak parts, on musical subdivisions, capped at 28 rows/s) and shortens the lock delay (0.55 s → 0.35 s). Game over resets the level.
• Key: the base hue follows the circle of fifths.
• Brightness, bass/air balance, dynamics, density: choose the mood (night, dusk or pale), the particle layouts, bloom, how strongly things react, and the camera's motion.
• Song structure: the song is split at bar lines into labelled segments (intro, verse, build, chorus, drop, break, outro), and segments that sound alike are grouped. Each segment eases the scene's density, speed, glow and saturation (builds ramp up, breaks thin out).
• One identity per song: background, main particles, blocks, frame and mood stay the same for the whole song. At most three intensity levels (calm, mid, peak) shift the hue slightly and add color, glow or an extra particle layer. Changes happen only when the level changes, crossfading over 8 s, and never interrupt each other.
• Calm by design: visuals follow slow (~1 s) envelopes of the music and there is no camera shake or flashing. Beat pulses appear only during peak sections (choruses, drops), stronger for faster songs; songs above ~110 BPM also get soft hits on strong transients there.
• Live bands and loudness, heavily smoothed, drive particle motion and glow.

The scene seed combines the song's fingerprint with a random seed for each run, so the same song looks different every time. The combinatorial space covers 8 palette schemes × 3 moods, 24 backgrounds, 38 particle layouts × 20 particle shapes (none, one or two layers), 12 continuous surface layers (smoke, silk, lava, caustics, ink, geometry, aurora, fog, beams, flowing rings, liquid, cloud shades), 22 block materials × a continuous family of block shapes (cube → rounded → sphere → gem), 18 board frames, a rare audio equalizer (3 layouts × 6 renderings × 4 resolutions × 3 colorings) and light rays, 22 line-clear effects, 25 transition shapes, and a post-processing grade (bloom, vignette, chromatic aberration, grain, split-toning). The scene name is shown in the bottom-left corner.

.github/workflows/wheels.yml builds wheels for Linux (x86_64, aarch64), macOS (x86_64, arm64) and Windows (x86_64) plus a source distribution on every push, and publishes them to PyPI when a v* tag is pushed (git tag v0.1.0 && git push --tags). Publishing uses PyPI trusted publishing: on pypi.org, add a publisher for project zentris, repository Gregwar/zentris, workflow wheels.yml, environment pypi.