 <p>Threads do not work, abstain from that approach.</p> <p>Creating several threads fails, as you have noticed, because only one thread has a current OpenGL context. In principle, you <em>could</em> make the context current in each worker thread before calling <code>glReadPixels</code>, but this will require extra synchronization from your side (otherwise, a thread could be preempted in between making the context current and reading back!), and <code>(wgl|glx)MakeCurrent</code> is a terribly slow function that will seriously stall OpenGL. In the end, you'll be doing <em>more work</em> to get something much <em>slower</em>.</p> <p>There is no way to make <code>glReadPixels</code> any faster<sup>1</sup>, but you can decouple the time it takes (i.e. the readback runs asynchronously), so it does not block your application and effectively <em>appears</em> to run "faster".<br> You want to use a <a href="http://www.songho.ca/opengl/gl_pbo.html#pack">Pixel buffer object</a> for that. Be sure to get the buffer flags correct.</p> <p>Note that mapping the buffer to access its contents will <em>still</em> block if the complete contents hasn't finished transferring, so it will <em>still</em> not be any faster. To account for that, you either have to read the previous frame, or use a fence object which you can query to be sure that it's done.<br> Or, simpler but less reliable, you can insert "some other work" in between <code>glReadPixels</code> and accessing the data. This will not guarantee that the transfer has finished by the time you access the data, so it may still block. However, it <em>may</em> just work, and it will <em>likely</em> block for a shorter time (thus run "faster").</p> <p><hr /> <sup>1</sup> There are plenty of ways of making it <em>slower</em>, e.g. if you ask OpenGL to do some weird conversions or if you use wrong buffer flags. However, generally, there's no way to make it faster since its speed depends on all previous draw commands having finished before the transfer can even start, and the data being transferred over the PCIe bus (which has a fixed time overhead plus a finite bandwidth).<br> The only viable way of making readbacks "faster" is hiding this latency. It's of course still not faster, but you don't get to feel it.</p>