I wrote a popular MVC framework for ColdFusion.  I ported it to Flex.  I've done large-scale Cairngorm projects, and been involved in PureMVC and Mate tasks.  The short of it all is that, for me, Swiz just owns the competition and any other MVC framework I've used in any environment.  If I wrote a new MVC framework for ColdFusion, it'd look like Swiz.

It does so for a very simple reason:  it's so simple that it's almost an anti-framework.  With the release of 0.6, it's possible to write a well-architected, notification-driven MVC RIA where (get this!) - none of your source code knows anything about Swiz.  Seriously.  There's no framework-linked IValueObject() that does absolutely nothing, no event maps to write, no framework-required listNotifications().  Heck, I think my last Swiz app didn't even import any classes from the framework except for the <swiz:SwizConfig> tag in its main application file.

Heresey you say?  A Flex framework without boilerplate?  No explosion of little procedural scripts hiding under impressively named Command pattern variants?  How's this?  It's all about Dependency Injection, Mediation, and Autowiring.  All you have to do is write plain old AS3 classes then sprinkle them with short and sweet Metadata to describe your application's behavior.

Dependency Injection (Beans.mxml)

In your Beans.mxml file, you define dependencies that your application needs:  Controllers, RemoteObjects, data models, Consumers, Producers, etc.  Think of it as a big configuration file.  If you use Spring (or ColdSpring), think of it like applicationContext.xml (Spring) or your ColdSpring.xml file (ColdSpring). 

Mediation

In Cairngorm, PureMVC, and all of the others, you have to jump through framework hoops to configure a system of application-level notifications:  events that aren't part of the UI hierarchy, such as informing your controller tier of inbound data from a Consumer or a user clicking "Save."

Swiz says "Forget that!" and uses an annotation (which could actually be framework-neutral!).  With the addition of UI-hierarchy event mediation (read:  Swiz handles bubbled UI events), that makes things ridiculously simple. 

In a view:

<mx:Button click="dispatchEvent( new Event('buttonClicked', true ) )" />

In a class named SomeController, which has nothing to do with Swiz and is just a plain AS3 class:

[Mediate( event="buttonClicked" )]
public function tellMeAboutIt() : void
{
    Alert.show("Someone clicked a button")
}

Any function on any view or Beans.mxml-registered bean (or any class you manually request wiring) for can use this insanely simple event system.  Like WinAMP, it whips the llama's arse.

Autowiring

Ever had fun binding to GiantGlobalVariablesLocator.getInstance().users?  Does it make you twitchy just having something like a big glop of global variables attached to a ModelLocator?  Swiz'll help there, too, and you don't need to use any framework classes to get there (or write a pseudo-Singleton implementation).

Going back to our button clicking example, let's pretend the SomeController.tellMeAboutIt() function did "this.buttonClickCount++", and that SomeController was registered in Beans.mxml and was bindable.  In any view, I can just do:

[Autowire( bean="someController") ]
public var someController : SomeController

Then, if I want to show click count:

<mx:Label text="Clicks: { someController.buttonClickCount }" />

Swiz'll go ahead and set the "someController" property automagically, and it'll just work.

Now, this does imply that the view knows about the API of the Controller, which is OK in MVC.  We can, however, decouple this (to keep the PureMVC users happy :) ):  just have tellMeAboutIt() dispatch a "buttonClickCountChanged" event that contains the new button click count.  A mediated function in the view (or a presentation model for the view, if that's your cup of tea) can listen for "buttonClickCountChanged" and update its state from the event's payload.  Yeeeeha!  View :: Controller decoupling with nothing but annotations!

Conclusion

Swiz takes about 30 minutes to learn.  15 if you know Spring or ColdSpring.  It provides all of the architectural decouplings of its competitors, but you only need to learn two annotations rather than a framework's API.  It's a no-brainer. 

Learn more about swiz at http://swizframework.org, or check out Brian Kotek's series on it at http://www.briankotek.com/blog/index.cfm/Swiz .