Good day all, I''ve been playing with Thin and Rack with the goal of making a web stack that uses common interfaces but is also truly eventable. My target demo application was a (semi-)scalable real time log tailing application, using no threads, and no developer space synchrony locks. The result of my couple of days hacking is that we might end up with a stable async api for Rack, assuming Chris2 is happy with the latest API changes we talked about. The api will be quite simple in principle, the result of a #call to the web application may return an HTTP status 100 (continue) if the connection is to remain open for future response. Additionally there is an extra environment variable handed with the rack request environment, specifically async.callback, which must respond to #call and begin to send any standard rack response sent to it. That''s concurrency patch number 1. Patch number 2 is support for DeferrableBody. Rack conveniently specifies that the third element in the response array must contain a body which may be serialized into ''chunks'' using #each. As #each takes a block, we can store that and callback later, remaining problems are close connection handling, which is in fact what the Deferrable is used for. In my implementation, continual rendering of body data on a long running request can be performed by using #call on the DeferrableBody, and the connection will be completed when the Deferrable succeeds (first callback). There may be the odd subtle synchrony error (been a bit rusty on synchrony it would seem), but in principle this thing works and scales really well. Other final bugs include double request bugs and a few other tiny things, maybe Tom would like to see if Thin is actually open to attack in this manner... (just send get after get, ignoring response content, and see what I mean - the only thing that stops this in Thin 0.8.1 is that clients aren''t asking for persistent connnections, and close_connection runs immediately after a request (and each request blocks the whole reactor loop)!). Enough babble, here''s the code: http://github.com/raggi/thin/tree/891cfc764027bd32ee39373b984e18175d82b007/example/async_tailer.ru N.B. You will need to install the thin fork from the above tree, and that''s the async_for_rack branch! If someone would be so kind as to do a PoC with Asymy or a similar tool, I''d love to see more numbers, the preliminary set I collected here look sound. Enjoy, James Tucker. P.S. I almost totally forgot the third async interface! If you''re running rails on top of thin with the aforementioned fork, you can also do a `throw :async` in your controller, after preparing an async callback using the async.callback env variable. This allows support for frameworks that don''t yet have any async handling capabilities. I haven''t actually tested this under rails, so again, it''d be really useful if someone would go and try this out. In theory this means you can have a long running xhr running out of a thin request, or even spawn off your long running requests to other daemons, with a Deferrable carrying a callback to send the response when it''s done. Worth also noting in this case that you''ll want to add the -t 0 flag to your thin command line.