The usual straightforward way to read data from a file is to invoke a read() function and receive the requested data directly in response. While this function is typically exposed through the programming language's standard library, it ultimately maps to a system call provided by the OS-kernel. Although this approach is simple in terms of program logic, it has the disadvantage that the calling thread is blocked, for an unknown amount of time, until the data becomes available. Blocking behaviour is particularly problematic in high-performance applications, because it reduces control over execution timing and may leave computational resources idle. Various interfaces and frameworks have been developed over time to address this issue, both for network communication and for file operations. The Linux kernel system call interface io_uring, adopted in kernel version 5.1 (2019) and gradually expanded since then, takes these efforts one step further by providing a uniform framework for many kinds of I/O operations: Client code submits requests to the kernel via shared queue, while completed work items are returned asynchronously through a second queue. In theory, this model allows extremely high throughput and very low latency. In practice, however, structuring client code to achieve these goals remains challenging. In our use case -- rendering video frames based on the timeline arrangement made by the film editor -- expensive computations must be chained behind I/O operations, all together involving a massive amount of data. The talk discusses common solution patterns and presents the approach taken by the Lumiera project to address these challenges. A simplified demonstration setup will then be explained using code examples in C++.