Best GWT widget library?

Question for all the GWT gurus out there - which is the best GWT widgets library out there? And why?

List based on the answers:

• Default
• Sencha GXT
• Smart GWT
• Vaadin
• GWT-Bootstrap
• GwtBootstrap3
• Rocket GWT (inactive)
• Tatami (inactive)
• ErraiFramework
• GWTMaterialDesign

И наконец- новое поколение основанное на http://ronanquillevere.github.io/2014/02/02/GWT-futur-javascript-interop.html#.VmCsmHYrJhE">JsInterop</a>;:

• GWT + Polymer Elements
• GWT + Polymer
• Angular and GWT
• GWTMaterialDesign

Do not bind yourself to ANY of these libraries. Use Vanilla GWT to create the structure of your project. In particular, use the MVP pattern and an Event Bus. Please, see google article to know how to best design your client application with GWT: Building MVP apps

After, you can use any widget of these libraries (say a table, or a combobox, a datepicker, etc) and incorporate it to your project. Try to use extended components ONLY if you don't see a way to do it with vanilla GWT. This way you don't tie yourself to these libraries which are ALWAYS a pain when you try to do something that doesn't appear in the demo application, contain many bugs and their support are poor at best.

How to look for widgets should follow this order:

• First check GWT Incubator to see if there's what I'm looking for. http://code.google.com/p/google-web-toolkit-incubator/
• Then, if you are looking for something "cooler" check GWT Mosaic http://code.google.com/p/gwt-mosaic/

Careful with other libraries, I've worked with them (and still have nightmares).

Depends on what you mean by "best". Best looking? Best API? Best for extending to your own custom needs?

E.g., I was just evaluating table classes to use in our application. We've been using GWT-Ext, but it has many performance problems for us, and is very hard to get the tables sized the way we need them. I came very close to going with GWT-Mosaic, but decided instead to build off the widgets in the GWT Incubator.

So, why did I make this choice? It seems that too many of the libraries out there come with their own, for lack of a better word, baggage. Either you have to dive whole-hog into some MVC framework (which may not be entirely compatible with the rest of your code base), or you have to adopt someone's new fangled layout system, or you have to live with the fact that you cannot really debug the code (because its just JSNI wrappers).

Don't get me wrong, the GWT Incubator isn't perfect...the widgets there are in some amount of flux. In my case, this was the best choice, though. It gives me good (but definitely not perfect):

• API
• Extensibility
• Look and feel (well, this is kinda weak, but that's what CSS is for.)

So...the answer (for me) is a combination of:

• Stock GWT widgets (with lots of custom styling)
• GWT Incubator tables
• A few home-grown widgets

(I should add: the "baggage" I'm referring to isn't necessarily a bad thing. But, if you just want a widget or two, it can raise the bar on what it takes to just get your work done and how good youe application looks.)

See this component library GWT Bootstrap this is a implementation in gwt of Twitter Bootstrap.

GWT alone is a pretty good library.

I didn't use all of the mentioned ones but can recommend Ext GWT.

I prefer vanilla GWT. Some of the other APIs look pretty and their showcases really show off the widgets, but I always find that the performance isn't the best....when I say performance I mean more like response time. I hate when an application feels sluggish.

Most of the libraries mentioned are not open source and even worse: are just wrappers on top of a JavaScript library. The power of GWT lies in the fact that the application works on different browsers (because of the code generation for the "big" browsers specifically). These JavaScript underlying libraries can cause lots of problems.

I agree with jgindin GWT Incubator and GWT Mosaic are the best so far.

Not saying it's "the best", but I've been using GWT-Ext at work lately. It's got some pros and cons:

Pros:

• Relatively easy to setup and use
• Decent sized community behind it
• LOTS of examples online, all of which have accompanying code
• Good selection of widgets that cover a wide range of functionality

Cons:

• Makes assumptions about your data's format and structure that you may not be able to accommodate
• Library is just a JSNI wrapper, which makes it harder to debug and extend
• Future support and development on the library is uncertain
• Some annoying cross-browser issues still exist (especially with layouts)
• Search function on their forums is essentially useless. (This is becoming a big pet peeve of mine >_<)

Do NOT use any of them! If you plan to develop a large scale application, you should consider using MVP pattern. The best implementation around is MVP4G framework, it supports GWT code splitting out of box. There are a lot of great examples, you can start with. The most valuable one is Mvp4GModules.

Add the new one: GWT-Bootstrap :)

There isnt a stable release right now, but will have soon.

My experience shows that there are always many problems with 3rd party libraries. The best way - is to use well-known and well-maked technology itself plus your own components. It may take a longer time to write and maintain them, but TCO is always at lower level.

3rd party libraries often can break your plans unexpectedly. And it's hard to find and fix the source of problem.

So I'd suggest to use plain GWT.

I think SmartGWT is fine if you just whant to use the Widgets as they are, but if you would like to extend or modify the widgets as I do in the Gxt Scheduler I think that Ext-GWT is a better choice.

for me EXT-GWT (aka GXT) is the best library currently available,I use it in 6 months project,and it helps a lot with many predefined components like grids,trees.... It's beautiful as well

SmartGWT is a good library and it has a lot of examples but the user interface is not that sleek. For user interface Ext GWT is good.

gwt-mosaic's user group doesn't seem very active and I couldn't find a user's manual besides the wiki snippets. gwt-mosaic introduced me to two interesting tools.

1. gwt-mosaic includes a wrapper for Tibco's PageBus which is a publish/subscribe tool for the JS parts of your app (RPC handlers, widget callbacks, widget setters). This is an alternative to gwt's event bus.

2. gwt-mosaic encourages the use of Beans Binding (http://code.google.com/p/gwt-beans-binding/) for binding data to widgets and validating widgets.

smartgwt isn't cheap for the full feature set and support. The jar is too large for appengine unless you remove the theme files you don't use. They invest engineering on the server side too.

I've heard ext-gwt is sluggish and the JS files are large.

The gwt widget incubator looks deprecated. I believe the deluxe grid will be released with the new gwt.

The lack of look-and-feel, binding, and validation standards is hampering the interoperability of widget libraries.

Definitely not SmartGWT. Their framework is bloated and has a very half-baked nature. They have a million widgets, but trying to get them to work for your project is not easy. Datasources complicate the process of managing your data in a very big way, for example, in order to get to data in your datasource, you must use fecth and inspect often. While you can cache the results, it is not always easy to interrogate them.

RPC is another weak and convoluted area. There is contradicting information in the documentation and in the forums. While the documentation will say that you should rarely use a custom operation as part of a ds, they forum will tell you that it's perfectly fine. Learning to use these tools effectively is an uphill climb on the best of days.

They will oversell the product. For example, the charting/analytics package contains graphs... But those graphs won't display negative values or let you manipulate axis labels in any meaningful way. And they openly respond to queries about this on the forum with a "yeah so what" attitude. "We don't plan on adding that to 3.0x even though that's one of our selling points, it's on our road map." When they sold me the package, they never mentioned that I couldn't display negative values. Really? What graph would not need to be able to show negative values? I can think of only one- the one depicting the number of unhappy Isomorphic customers.

Stay away from these guys, and head over to any competitor's site, for example ExtJS, JQuery, heck even quxdoo. There are a few projects out there that are really gaining ground and actually offer a good solution.

Take great caution if you ever evaluate this product. It looks nice, but about two weeks in to the project using it, you'll start seeing what I mean. Widgets are half baked, datasources are extremely over complicated, and just because you paid for forum support, doesn't mean you'll actually get anything other than snide, condescending answers that at first will make you think you missed something. You didn't they're generally very arrogant.

Best of luck, and stay away from this product if you value your development time and maintainability. Oh and one last thing. Look at the MVC example on their web site. It has literally nothing to do with MVC other than the label reads "MVC". They'll try to convince you that such frameworks are for inexperienced developers, and that such a concept has no place in real programming... Kinda like those try catch blocks.

Google's default library is the most powerful library.

Ext GWT adds bells and whistles but apart from that it's similar to Google's.

I would say if you need only a few widgets then build your own. You might copy-paste some concepts from the libraries mentioned. But they all lack one or the other thing. I have played with most of them and abandoned every one.

We're currently liking the GWT Mosaic widgets. We've worked with ext-JS and we've rolled our own widgets in the past. ext-JS licensing and bulk were a problem for us. Rolling our own isn't what we want to do. Mosaic gives us a happy middle ground which we like to think will be an even happier middle ground as the project matures.

One thing to be aware of is that from the forums GWT-Ext looks like it will no longer be developed/maintained much (maybe not at all?). On their website they recommend migrating to SmartGWT.

Didn't see this one mentioned, Vaadin (previously known is IT Mill Toolkit), but maybe that's because it's not technically exactly GWT; as their FAQ says:

> How does this differ from GWT? > > GWT applications run in the browser, > while Vaadin applications run on the > server. We do actually use GWT as a > "rendering engine" on the browser > side, so you can combine Vaadin and > GWT.

smartGWT is slow and examples are lacking and it is very hard to find answers for even the basic questions, i.e. see all my non answered questions on this forum. I'm dumping smartgwt.

Comparison of the two EXTs here with pros and cons.

We have built a large HR portal and a couple of smaller applications using GWT Portlets. The focus of the project is not so much on building a collection of widgets but on creating a simple programming model.

From the website:

GWT Portlets is a free open source web framework for building GWT (Google Web Toolkit) applications. It defines a very simple & productive, yet powerful programming model to build good looking, modular GWT applications.

The programming model is somewhat similar to writing JSR168 portlets for a portal server (Liferay, JBoss Portal etc.). The "portal" is your application built using the GWT Portlets framework as a library. Application functionality is developed as loosely coupled Portlets each with an optional server side DataProvider.

I am using GWT for a year. After lots of research, I have decided GWT Mosaic as a widget library.. Mosaic uses some of the GWT incubator components such as PagingScrollTable.. But the features of the combobox and table are not sufficient for us.. That is why, we have extended these components to add needed functionality.

Check out SpiffyUI: www.spiffyui.org

It is not just a widget library but complex UI/UX GWT framework.

Two important things -and what the most of libraries miss- are unit testing and debugging. It is where GWT shines. If you use a library which is based on vanilla js, you give away the ability to unit test and debug your project. As a GWT developer you should consider these points and use a library with no or minimal js dependency.

We've been doing gwt projects for more than 2 years, and we stick to the default widgets. We made our own open source library to autopopulate the default ones or our own widget extensions. Please check it, it's called gwt-jet. It's very well tested since we use it in large production environments, and we hope it will grow safely thru time.