Best GWT Libraries: Ext GWT (GXT) vs GWT-Ext vs SmartGWT

The Ext GWT, SmartGWT and GWT-Ext are the most used and cool widget frameworks on top of the GWT.

As of today the current versions of these libraries can be downloaded from here:

1. Ext GWT (GXT)

Ext GWT is a Java library for building rich internet applications with the Google Web Toolkit (GWT). It's built directly using GWT with no extra JavaScript library, just using pure GWT-ish Java code and an extensive gxt-all.css file. The output of this library is identical to that of GWT-Ext as it is also based on the ExtJS library, but GXT is lighter and faster than it's GWT-Ext counter-part.

Ext GWT has several licensing options available to fit a variety of needs including open source and commercial licenses. For more information, please visit the license page.

For eclipse IDE there is available a plugin to help developement  called Ext GWT Help Plugin. This one can be installed from the

2. SmartGWT

SmartGWT is a GWT wrapper framework on top of a JavaScript library. It allows you to not only utilize its comprehensive widget library for your application UI, but also tie these widgets in with your server-side for data management. Smart GWT is based on the powerful and mature SmartClient library, and it works in a similar way like GWT-Ext.

Smart GWT is compatible with GWT 1.5.3 , GWT 1.6.4, GWT 1.7.x and GWT 2.0.
There is available also a commercially licensed version of SmartGWT that includes Java Server side functionality, additional tools, and a classic commercial license in lieu of the LGPL. (showcase). An evaluation can be downloaded from here.
Here is presented  the comparison between different versions of SmartGWT library.
3. GWT-Ext

GWT-Ext is a quite advanced GWT wrapper framework on top of a JavaScript library. It helps tie together the functionality of the Google Web Toolkit and the widgets available in the ExtJS javascript library, which is very stylish, functionality rich and most of all performant. Too bad that's dead now!!!

GWT-Ext does not distribute ExtJS, which you need to include in your project. Note that GWT-Ext only supports ExtJS versions 2.0.2 or lower. You can download Ext 2.0.2 from here. Ext 2.0.2 has a variety of licensing options and LGPL 3.0 is one of them. The license file can be found in its distribution, or you can find it here.

It has also an extension library, called GWT-Ext-UX, developed by users like you :)

Here's a simple graphical representation of what I enumerated above:

4. Personal experience

I've used for developement the GWT-Ext and GXT libraries, so far.

The GWT-Ext is a very good, easy to understand and use. After it was "sacked" we had to find out a replacement.

The API of the SmartGWT was completly different (i.e. name of the methods, which do same thing, were complete different, either because of the javascript underneath, or just for the sake of it - we'll never know).

The GXT is a very good candidate for the migration from GWT-Ext, because lots of APIs are the same or very similar. It uses pure GWT principles making applications more efficient / compact; also, it uses the MVC (not MVP as I said earlier -- my bad!) pattern, but the events manipulation is quite different (Listeners instead of Handlers), though, this is acceptable, and even you have to pay for, it's worth it.

If I'd start from scratch the SmartGWT would be the choice. Only from looking at the SmartGWT showcase, this seems very rich in UI controls, and not only that, the server side has some good tools too. Also, with the latest versions the look and feel has improved a lot, and I would go with it, not only for fun and learning new stuff, but it seems a really good job.


Similar articles:
* JVM Web Framework Comparison


  1. For pure java programmers who grew up on servlets, has a great alternative to these client-server models that all have their DTO+RPC issues to deal with.

  2. Vaadin doesn't "solve" the DTO+RPC issue any more than JSF does. It's simply a server-oriented framework with server-side event handling, so the DTO+RPC issue doesn't arise. The trade-off is that the highly interactive UIs that users now expect can't be built without an unacceptable amount of server contact. Examples include rapid data entry with field inter-dependencies, customized client-side filter and sort, and custom drag and drop interactions.

    In all of the server-centric frameworks - JSF, Vaadin, ZK - there is some very convoluted way to sort-of do client-side event handling, but then, in this case, the RPC+DTO problem re-appears.

    SmartGWT Pro really *does* solve the RPC+DTO problem, *and* supports client-side event handlers in Java. Both the nature of the DTO problem and the SmartGWT solution are explained by the creator of GWT-Ext (Sanjiv Jivan) here:

    Finally, on performance, scalability is what counts. In advanced use cases, like grids with many columns, Ext gets unacceptably slow while SmartGWT continues to perform well (because SmartGWT render only visible columns in large grids).

    There are many such cases, here's another:

  3. For the ones who don't know what DTO is, here is a very good explanation of the design pattern,


  4. Sorry, but this is not a comparison, you are just saying what is each one. Too much superficial...

  5. GXT is really positioned to use MVC, not MVP. It even includes a light MVC framework. To be more MVP-friendly, GXT needs to implement the GWT Has* interfaces.

  6. Yes, MVC not MVP ... you're right ... thanks!