Elsewhere in this discussion-

  Jetlang doesn't offer lightweight-threads. It uses an 
  event-driven processing of messages (like Akka), so fibers 
  can't block and you can't do selective receives.

https://news.ycombinator.com/item?id=5646097

Akka relies on operating system threads- when you block in Akka, you block in real life.

According to this Akka document - http://doc.akka.io/docs/akka/1.3.1/scala/dispatchers.html

"Akka supports dispatchers for both event-driven lightweight threads, allowing creation of millions of threads on a single workstation, and thread-based Actors, where each dispatcher is bound to a dedicated OS thread."

I also, would like to see the perceived shortcomings of Akka, since lightweight threads can't be the problem.

Akka calls them lightweight threads, but they really aren't as they can't be blocked. In short - they're not implemented as continuations.

Basing the implementation on real lightweight threads gives you selective receive and other goodies mentioned in the post, while maintaining the API simple. I think Quasar/Pulsar are much simpler than Akka, and they will stay simpler for said reason.

All in all, Akka feels a lot more complicated than Erlang. Also, Scala isn't everyone's cup of tea, and Akka doesn't mesh well with Clojure.

Quasar tries to join the power of Erlang with the power of the JVM. Pulsar tries to join the beauty and elegance of Erlang with the beauty and elegance of Clojure.

Akka works fine from Java and Clojure (http://doc.akka.io/japi/akka/2.1.2/ | https://github.com/jasongustafson/akka-clojure)

All well and good, another measure of "lightweight" that is often quoted is a little over 300 words of overhead/erlang BEAM process and 300 bytes/akka actor, do you have comparables for Quasar?

http://www.erlang.org/doc/efficiency_guide/processes.html

http://doc.akka.io/docs/akka/snapshot/general/actor-systems.... (300 bytes: way at the bottom

Quasar actors consume even less memory. An idle actor occupies about 500 bytes.