I am also confused, i have seens developers at the company i work for who learns some really complex frameworks and libraries, then when i show them some gwt project, they argue that they need lots of time to learn it, come on ... A java developer needs time to learn java ???!!!!!! How that could be???!!! Gwt is basiclly java nothing more, you just get that java to javascript transpiler as extra.

Recently i was able to make my own gwt platform in which i made a simple todo application that using the same code base, i could run it as web application with 2 different flavour of the ui, polymer elements and material design widgets, and as a plus the same application using the same code base now runs as a desktop application using javafx.

I dont think js frameworks can give you that, I CANT IMAGIN A BETTER GWT THAN THIS YET I AM WAITING FOR ONE BECAUSE THERE WILL BE ONE.

I am already doing this fight in the company i work for, yet the best way is always as in any code argument ..show the code, i show something working, this is how you promote it, yet they will still resist, and you should insist.

and for the community you can always contribute to the projects built around GWT in github, you can also join gitter chat channels, join the forums,  answer questions,  make questions, and try things out .

Its been a while since i used the GWT eclipse plugin, i use archetypes to create new quick start projects 

https://github.com/tbroyer/gwt-maven-archetypes

and i do build my own sometimes, what one might use the plugin for is for debugging in the IDE and yes this might a point to work on and i think there were some work done around it since the last year.

I am with the UiBinder, i love it, yet i am ready if its gone, there is actually more one replacement that are focused on HTML templates. for this you can check Errai UI http://erraiframework.org/getting-started/index.html#ErraiUIPage

but i personally prefer another alternative which is elemento https://github.com/hal/elemento

i prefer elemento because its a lightweight and focused and it provide a Builder API, here is a sample i implemented using elemento and vaading-gwt-polymer-elements that uses HTMLTemplates without any UiBinders

https://github.com/vegegoku/todolist-elemento

I do use restful too over restyGwt, and works great when you are dealing with simple data structures using simple datatypes, but when it comes to complex datatypes it does not perform good, for example, with RPC you got polymorphic types out of the box and there is nothing you need to to, with rest you still need to teach your application about these polymorphic types, its doable but with extra work, then comes other long list of datatypes that not well supported by rest like dates, bigdecimals, enums, maps....etc, RPC in this is much more powerful and type safe, and provides a stronger contract, it might have problem but it also has lots of strength in it.

I tend to agree with that, and i know that we can contribute to this part, and i will try to do something in there when i got some time.

I have been in the position you are in now, but i have few things to say:

First : we had the same slow compilation issue you already have, we have a framework that was built with GWT we started with GWT 2.1 if i remember, the framework handles the ui part of all of our application and we distribute it to other teams and they only write backend code, but one of the issues was the labels, for every language we add that was + 1 X Supported browsers permutation, so we started initially with about 12 permutations, and to make things worse, application team has nothing to allow them to build the framework on development machine and they could only do that by building from bamboo, so changing one label or adding one labels needed around 50 minutes to see the effect on the developer screen, it was a pain, but we didnt panic, but actually we looked for a solution, and by externalizing our labels and internationalization stuff we ended up with a constant number of permutations of 3 and less than 20 minutes total build time , not only that we also now dont need to rebuild the whole framework for a label change, with our solution you change the labels then you click a button and you refresh the page, that is less than 3 seconds, and we lived happy for ever after. my point is that you need to identify what makes your build slow and fix it.

Second : regarding GWT 3.0, you should not wait, really, remember that you are writing java, and it is easy to make a good structure for your app, doing so you can isolate the parts that might change later and it will be easy to replace or change them, and actually in this part if we compare GWT with angular i think GWT wins, angular as you said keep announcing things and put a road map, but a road map that breaks things and does not care for backward compatibility, remember what happened with angular 1, while in the other hand GWT gave us hints and suggestion and  the most important TIME, to change and to be ready, it was a clever move not to make sudden major changes, i would really thank the steering committee for this. they hinted that we need to avoid widgets but they kept them while introducing elemental, to avoid generators but kept them while introducing APT, to avoid RPC's but kept them while introducing REST, so in fact i am writing GWT applications now without fear, and i wouldnt be in such calm state if i were to use angular and every day they comes up with dramatic change.

Last : That management and what they think thing, i have been in this position before too but with in different topic, 6 years ago i fought so hard with the management to convince them that clean code matters and is very important, i fought for a year but the answer was always -as long things works we dont care if its clean or not- and year after year they paid the bill. 2 years ago and finally the CTO admitted that he was wrong and clean become a policy, and none clean code will not be committed into our repositories, with TDD and clean code applications of 120K LOC were written for 25k LOC and they performed better and had less than 10% bugs of the original code base. 

the bottom line is : when it comes to technical decisions you are the expert the management guys let them focus on the requirement and policy and take the implementation part but still you also need to hold responsibility. our CTO now have no role in picking up technologies since it is our job, he might suggest one but we research it we do POC's and we give the final decision.

and one more: GWT is not about google any more, the steering committee are doing an amazing job, i have seen GWT advancing during the life time of the steering committee much better than before, they are like the user perspective being considered into GWT, and if you really want to hear more about J2CL, wait for the conference presentations, having no one from google does not mean that J2CL is not going to be discussed in the conference, its a GWTcon not google conference. 

I just remembered another thing, i was able able to integrate vertx event bus with my gwt application on the client side by implementing sockjs methods using JsInterop, with just few JsInterop small interfaces and classes i was able to enable server push messagea from any node in a clustered and non clustered envirounment. It was like a sweet magic. Love JsInterop.

I implemented the browser state api for history handling in one of my project, i used elemental2 for this but with jsinterop i was able to add the missing parts from the elemental implementation.

JsInterop one best things ever happened to gwt i am still going to try to utilize it even more.

Thanks for clearing things out +1.