A clean, lightweight alternative to Python?

One (a long time ago) I wrote a web spider and I multithreaded the thread to allow concurrent requests to happen at the same time. That was my Python youth, before I learned about the GIL and its associated troubles for multithreaded code (IE, most of the time, these things end up being serialized!)...

I would like to redo this code to make it more robust and perform better. There are basically two ways to do this: I could use the new multiprocessing module in 2.6+ , or I could use some kind of reactor/event based model. I'd rather do it later because it's much simpler and less error-prone.

So the question is about which framework is best for my needs. Here is the list of options I know so far:

• Twisted : The grandfather of the Python reactor framework: It looks complicated, but it's a bit bloated. Steep learning curve for small tasks.
• Eventlet : From the guys at lindenlab . A Greenlet-based framework for such tasks. I took a look at the code, but it doesn't look pretty: it's not Pep8 compliant, with prints scattered around (why would people do this in a framework!?), the API seems a bit inconsistent.
• PyEv : immature, although it's based on libevent, nobody seems to be using it, so it has a solid backend.
• asyncore : from stdlib: über low level, seems like a lot of work involved just to get things off the ground.
• Tornado : Although this is a server-oriented product designed to serve dynamic websites, it does have an asynchronous HTTP client and a simple ioloop . Seems to get the job done, but not as intended. [EDIT: Unfortunately it doesn't work on Windows, which counts as it for me - it's my requirement to support this lame platform]

Is there anything I'm missing? Of course, there must be a library that fits in the sweet spot of simplifying async networking libraries!

[Edit: Many thanks to intgr for pointing to this page . If you scroll to the bottom, you will see a very nice list of projects designed to solve this task in one way or another. In fact, things have indeed changed since Twisted was born: people now seem to prefer coroutine -based solutions over traditional reactor/callback oriented solutions. The benefit of this approach is more straightforward code: I did find it in the past, especially when using boost.asio. In C++, callback-based code can lead to hard-to-follow designs and is relatively obscure to the untrained. Using coroutines allows you to write code that looks at least more synchronous. I guess my task now is to find out which of the many libraries I like and give it a try! Glad I'm asking now...]

[EDIT: May be of interest to anyone following or stumbled upon this question or the subject in any sense: I found a really good article on the current state of the tools available for the job ]