Kinoteca Icon

Kinoteca

Local media center in Rust with hardware-accelerated WGPU rendering

Studio-quality video and audio running directly on your GPU. No internet. No subscriptions. No Electron.

LEARN MORE
Kinoteca Catalog Kinoteca Settings Kinoteca Player

Tonemapping and Color

Mathematically precise pipeline. Translating PQ into linear space, gamut mapping from BT.2020 to BT.709 with skin tone protection and elimination of highlight color shifts.

Color Swatches

Adjust brightness, saturation, vibrance, contrast, gamma

3D LUT

Built-in support for 3D LUT tables

SDR Video
HDR Video
‹›
SDR (Washed)
HDR Tonemapped
Source HDR
→
Tonemap / LUT
→
SDR Output
Video Frame

Sharpness

⋮⋮

Blur

⋮⋮

Grain

⋮⋮

Chroma

⋮⋮

Generative Video Processing

Control the image at the GPU level.
High-precision upscale, film emulation, and deterministic grain.

You can drag blocks of shaders with the mouse by the icon on the right to change processing order, and tweak the sliders. The image on the left renders instantly. The effects are real.

You have the opportunity to write your own custom shaders!

Studio-Grade Audio Engine

Audio processing should not create latency. The built-in DSP uses real-time saturation and equalization. Play the video on the right and adjust the sound with the sliders below.

Equalizer (Real-time EQ)

Saturation (Distortion)

00:00 / 00:00

Purchase Program

The media center is delivered as a single portable executable, requiring no installation or internet connection.

Lifetime license for only 590 RUB

BUY KINOTECA

Frequently Asked Questions

How is the video player implemented and how does it achieve a smooth frame rate?
The video engine is written in system Rust using low-level ffmpeg-next bindings and is completely decoupled from the UI rendering thread. Video frame and audio packet decoding occur in parallel background threads. Decoded frames are passed into a lock-free queue with zero memory allocations in the render loop, and their output is synchronized via the high-precision system clock of the audio card (audio-driven sync). This eliminates UI latency and guarantees absolutely smooth 60 or 144 FPS with no dropped frames or micro-stuttering.
How is the tonemapping and HDR/SDR system structured?
The media center has its own linear-space tonemapping pipeline. A video frame in YUV420P16LE format is converted to RGB taking into account the source color space (BT.709, BT.601, BT.2020). When playing HDR on an SDR screen, pixels are translated from the PQ curve into linear space, undergo desaturation of overly bright shades, skin tone protection, and soft highlight compression (Knee/Roll-off) according to the Uncharted 2 algorithm, and then converted to sRGB OETF for screen output.
Why was WGPU chosen for the graphical interface instead of Electron or WebView?
Using WGPU allows rendering the entire application interface directly through Vulkan, DirectX 12, or Metal with hardware acceleration, bypassing heavy browser engines like Chromium. The program compiles into a single lightweight binary file, consumes less than 100 MB of RAM, and runs with minimal CPU overhead, leaving all system resources for video decoding and shader processing.
How do custom video shaders and 3D LUTs work?
All image post-processing occurs on the GPU using WGSL shaders. 3D LUT tables (.cube format) are converted into three-dimensional Rgba32Float textures on the graphics card. Color mapping is performed using tetrahedral interpolation in the fragment shader, providing cinematic color transitions with zero banding and minimal VRAM overhead.
How is real-time audio processing structured?
The audio pipeline operates in 32-bit Float mode at a 48 kHz sample rate based on the cross-platform SDL2 library. Decoded audio enters the lock-free ringbuf buffer. The chain includes an 8-band parametric equalizer on biquad filters and a Soundgoodizer module, which splits the signal into 3 bands (crossover with Linkwitz-Riley filters) and applies independent compression and a non-linear saturator.
Why is SSE assembly code used in the audio processor?
To achieve ultra-low latency and prevent digital clipping (overdrive) during extreme limiter adjustments. The signal amplitude limitation algorithm is optimized manually at the level of SSE CPU instructions using built-in Rust assembly (asm!). This guarantees that signal peaks are softly smoothed using the hyperbolic tangent function in a minimal number of CPU cycles, completely eliminating audio stutters.