Getting Started with the GWT 2.0 Release Candidates

Before using GWT 2.0 RC2 or RC1, please understand that they are release candidates and will change before the official release. We do not recommend using these release candidate builds for production applications.

This release contains big changes to improve developer productivity, make cross-browser development easier, and produce faster web applications.

Downloading and Installing GWT 2.0 RC SDKs

No installation process is required to use the GWT SDK; simply unzip it into any convenient directory.

Download GWT 2.0 RC2

Download GWT 2.0 RC1

The new debugging support in GWT 2.0, called Development Mode, requires a native browser plugin that will be installed on-demand as you use GWT. See "Getting Started with Development Mode" below for step-by-step instructions for this process.

Downloading and Installing the Google Plugin for Eclipse 1.2 RCs

Google Plugin for Eclipse 1.2 RC1 includes functionality to support the new features in GWT 2.0, so if you're an Eclipse users, we highly recommend installing it as well.

Installation Instructions

Download the Google Plugin for Eclipse 1.2.0 Release Candidate zip distributions for your version of Eclipse:

RC2

• 3.5 (Galileo): http://dl.google.com/eclipse/plugin/3.5/zips/gpe-e35-1.2rc2.zip
• 3.4 (Ganymede) http://dl.google.com/eclipse/plugin/3.4/zips/gpe-e34-1.2rc2.zip
• 3.3 (Europa): http://dl.google.com/eclipse/plugin/3.3/zips/gpe-e33-1.2rc2.zip

RC1

• 3.5 (Galileo): http://dl.google.com/eclipse/plugin/3.5/zips/gpe-e35-1.2rc1.zip
• 3.4 (Ganymede) http://dl.google.com/eclipse/plugin/3.4/zips/gpe-e34-1.2rc1.zip
• 3.3 (Europa): http://dl.google.com/eclipse/plugin/3.3/zips/gpe-e33-1.2rc1.zip

Note: Ensure that your version of Eclipse has Eclipse's Web Standard Tools (WST) installed before installing the plugin. WST can be installed by navigating to the Software Installation section, and selecting the the appropriate WST feature from the update site for your version of Eclipse. The update sites and feature names are provided below.

• 3.5 (Galileo): Galileo -> Web, XML, and Java EE Development -> Eclipse Web Developer Tools
• 3.4 (Ganymede): Ganymede Update Site -> Web and Java EE Development -> Web Developer Tools
• 3.3 (Europa): Europa Discovery Site -> Web and JEE Development -> Web Standard Tools Project

It is strongly recommended that you install the release candidate on a fresh install of Eclipse and use a clean workspace.

Finally, follow these instructions for installing the plugin from a zip distribution.

Important Notes

Terminology changes

We're going to start using the term "development mode" rather than the old term "hosted mode." The term "hosted mode" was sometimes confusing to people, so we'll be using the more descriptive term "development mode" from now on. For similar reasons, we'll be using the term "production mode" rather than "web mode" when referring to compiled script.

Changes to the distribution

Note that there's only one download, and it's no longer platform-specific. You download the same zip file for every development platform. This is made possible by the new plugin approach used to implement development mode (see below). The distribution file does not include the browser plugins themselves; those are downloaded separately the first time you use development mode in a browser that doesn't have the plugin installed.

Major New Features in the GWT SDK

In-Browser Development Mode

Prior to 2.0, GWT hosted mode provided a special-purpose "hosted browser" to debug your GWT code. In 2.0, the web page being debugged is viewed within a regular-old browser. Development mode is supported through the use of a native-code plugin called the "Google Web Toolkit Developer Plugin" for many popular browsers. In other words, you can use development mode directly from Safari, Firefox, IE, and Chrome.

Developer-guided Code Splitting

Code splitting using GWT.runAsync(), along with compile reports (also known as The Story of Your Compile) allows you to chunk your GWT code into multiple fragments for faster startup. Imagine having to download a whole movie before being able to watch it. Well, that's what you have to do with most Ajax apps these days -- download the whole thing before using it. With code splitting, you can arrange to load just the minimum script needed to get the application running and the user interacting, while the rest of the app is downloaded as needed.

Declarative User Interfaces with UiBinder

GWT's UiBinder now allows you to create user interfaces mostly declaratively. Previously, widgets had to be created and assembled programmatically, requiring lots of code. Now, you can use XML to declare your UI, making the code more readable, easier to maintain, and faster to develop. The Mail sample has been updated to show a practical example of using UiBinder.

New Layout Panels for Fast and Predictable Layout

A number of new panels were added, which together form a stable basis for fast and predictable application-level layout. The official doc is still in progress, but for an overview please see Layout Design on the wiki. The new set of panels includes RootLayoutPanel, LayoutPanel, DockLayoutPanel, SplitLayoutPanel, StackLayoutPanel, and TabLayoutPanel.

Bundling of Resources via ClientBundle

GWT introduced ImageBundle in 1.4 to provide automatic spriting of images. ClientBundle generalizes this technique, bringing the power of combining and optimizing resources into one download to things like text files, CSS, and XML. This means fewer network round trips, which in turn can decrease application latency -- especially on mobile applications.

Simplified Unit Testing with HtmlUnit

Using HtmlUnit for running test cases based on GWTTestCase: Prior to 2.0, GWTTestCase relied on SWT and native code versions of actual browsers to run unit tests. As a result, running unit tests required starting an actual browser. As of 2.0, GWTTestCase no longer uses SWT or native code. Instead, it uses HtmlUnit as the built-in browser. Because HtmlUnit is written entirely in the Java language, there is no longer any native code involved in typical test-driven development. Debugging GWT Tests in development mode can be done entirely in a Java debugger.

Major New Features in the Google Plugin for Eclipse

Development Mode Launch View

Integrates your Development Mode logs right into Eclipse, which means one less window to shuffle around

UiBinder Support

The UiBinder template editor provides auto-completion and formatting for editing ui.xml files (and embedded CSS blocks)

Validation of UiBinder templates and backing Java classes

New UiBinder wizard to quickly get started

ClientBundle Support

"New ClientBundle" wizard to bundle CSS and other resources together to minimize HTTP round-trips

As-you-type validation ensures that your app's static resources are always in the right place

RPC Refactoring

Automatically updates sync/async pairs of RPC interfaces and their methods

JNSI Reference Auto-completion

Auto-completion takes the pain out of referencing Java members from JSNI methods

Getting Started with Development Mode

Step 1: Start Development Mode

The first time you launch development mode in GWT 2.0, you might be surprised that not much seems to happen. All you will see is something like this on the console:

 Using a browser with the GWT Developer Plugin, please browse to
 the following URL:
   http://192.168.1.42:8888/Hello.html?gwt.codesvr=192.168.1.42:9997 

(where 192.168.1.42 is your own IP address)

Step 2: Open a browser

Open the browser you want to use to view the GWT application you're debugging.

If this is the first time you've ever attempt to use development mode with that browser, you will not yet have the GWT Developer Plugin installed, so you'll see a page that instructs you to install the plugin. Once you download and install the plugin, restart the browser and navigate again to the URL from above, making sure it includes the gwt.codesvr query parameter.

When installing the GWT Developer Plugin on Windows 7, certain configurations may require you to explicitly save the installer as a file and then "Run as Administrator".

Note that the first time you access your GWT module from a browser, it may appear to hang momentarily as your module loads. This is normal. Subsequent refreshes within the browser are much faster as long as you keep the development mode session running.

Step 3: Follow the Edit/Save/Refresh cycle without restarting development mode

At this point, use your Java debugger as normal.

Because refeshes are much faster than the initial load, it is strongly recommended that you simply leave development mode running, because you can continue to edit and save any of your projects files -- including .html, .css, .java, .gwt.xml, and .ui.xml files -- and simply refresh to pick up changes.

Step 4: Open additional browsers for testing

You can open any number of additional browsers to ensure your application behaves properly across browsers.

Breaking changes and known issues/bugs/problems

• Windows users who have previously installed the Google Web Toolkit Developer Plugin for IE will have to uninstall the old version. Use the following steps:
1. From the Windows "Start" Menu, open "Control Panel"
2. Select "Add/Remove Programs"
3. Select "Google Web Toolkit Developer Plugin for IE" then click "Uninstall"
4. Run Internet Explorer and browse to http://gwt.google.com/samples/MissingPlugin to install the new version of the plugin.
• The -portHosted Development Mode flag has been renamed to -codeServerPort.
• The release notes included with RC2 contain one inaccuracy: the Image.onload event still does not fire on Internet Explorer when image is in cache. See issue 863 for more details.
• Prior to 2.0, GWT tools such as the compiler were provide in a platform-specific jar (that is, with names like gwt-dev-windows.jar). As of 2.0, GWT tools are no longer platform specific and they reside in generically-named gwt-dev.jar. You are quite likely to have to update build scripts to remove the platform-specific suffix, but that's the extent of it.
• The development mode entry point has changed a few times since GWT 1.0. It was originally called GWTShell, and in GWT 1.6 a replacement entry point called HostedMode was introduced. As of GWT 2.0, to reflect the new "development mode" terminology, the new entry point for development mode is com.google.gwt.dev.DevMode. Sorry to keep changing that on ya, but the good news is that the prior entry point still works. But, to really stay current, we recommend you switch to the new DevMode entry point.
• Also due to the "development mode" terminology change, the name of the ant build target produced by webAppCreator has changed from hosted to devmode. In other words, to start development mode from the command-line, type ant devmode.
• HtmlUnit does not attempt to emulate authentic browser layout. Consequently, tests that are sensitive to browser layout are very likely to fail. However, since GWTTestCase supports other methods of running tests, such as Selenium, that do support accurate layout testing, it can still make sense to keep layout-sensitive tests in the same test case as non-layout-sensitive tests. If you want such tests to be ignored by HtmlUnit, simply annotate the test methods with @DoNotRunWith({Platform.HtmlUnit}).
• Versions of Google Plugin for Eclipse prior to 1.2 will only allow you to add GWT release directories that include a file with a name like gwt-dev-windows.jar. You can fool it by sym linking or copying gwt-dev.jar to the appropriate name.
• The way arguments are passed to the GWT testing infrastructure has been revamped. There is now a consistent syntax to support arbitrary "run styles", including user-written, with no changes to GWT itself. For example, -selenium FF3 has become -runStyle selenium:FF3. This change likely does not affect typical test invocation scripts, but if you do use -Dgwt.args to pass arguments to GWTTestCase, be aware that you may need to make some changes.
• When using ClientBundle, be aware that images using alpha transparency do not appear transparent in IE6. The Mail sample application included in the GWT distribution currently suffers from this limitation (that is, the images have opaque backgrounds when viewed on IE6).