The programming model of Vaadin is beautifully simple and fun

It's similar to what GXT/GWT promises to be, but even simpler. You can stop agonizing over Java-to-JavaScript compilation time, data serialization, and asynchronous calls. Read on to find out why Vaadin is a great alternative to GXT and what the key similarities and differences are.
vaadin_architecture

Learn how to migrate from GXT to Vaadin 8

Download a free guide for migrating GXT applications to Vaadin framework. The guide goes through seven practical steps for smarter migration and contains a full sample project.

  • Reuse the majority of your existing GXT/GWT code base as is
  • Use a development model similar to GXT
  • Rewrite the UI layer gradually and only when needed
Download the Free Guide

Things that make you feel right at home
java 
VerticalLayout layout = new VerticalLayout();
Button button = new Button("Click Me!");
layout.addComponents(button);

Java on the server-side with automated communication to the client

Vaadin’s API is 100% Java. Vaadin applications are run on Java Virtual Machine in the server and the client is JavaScript compiled from Java in the browser - no plugins required. In addition to Java, you can use any JVM language. No HTML or JavaScript is needed.

HTML 
<vaadin-vertical-layout size-full>
  <vaadin-button style-name="primary" 
                 plain-text _id="button">
    Click Me!
  </vaadin-button>
</vaadin-vertical-layout>

Declarative Support

Vaadin views can be defined using declarative syntax.

Java 
Button button = new Button("Click Me!");
button.addClickListener(event ->
  Notification.show("You clicked the button!"));

Event driven programming model

Vaadin Framework offers an event-driven programming model for handling user interaction.

Java 
Grid grid = new Grid<>();
grid.setItems(persons);
grid.addColumn(Person::getFirstName)
  .setCaption("First Name");
grid.addColumn(Person::getLastName)
  .setCaption("Last Name");

Easy databinding

Vaadin provides a data binding API for user interface components to update the application data directly, often without the need for any control code.

Read more

Easy and strong abstraction of complex web technologies

The Vaadin engine runs in the browser as JavaScript code, rendering the user interface, and delivering user interaction to the server. As the client-side engine is executed as JavaScript in the browser, Vaadin supports a wide range of browsers, so that the developer does not need to worry about browser support.

Component based architecture

A familiar component-based programming model helps you to build modern single-page HTML5 apps easily. You can apply the skills you have learned with previous UI frameworks, like Swing and GWT, and concentrate on your domain problems and get a much more modern UI.

Large collection of good-looking widgets

Vaadin UI components come with a fresh theme and a font icon set built-in. The Valo theme engine allows easy customization with SASS variables.

No browser plugins are needed for using applications made with Vaadin. The UI logic of an application runs as a Java Servlet in a Java application server. HTML, JavaScript, and other browser technologies are essentially invisible to the application logic.

Things that make you never want to go back

Server-side architecture keeps your UI code and data secure

Vaadin applications are run on a Java application server. The UI code and business logic is run securely on the server runtime. You are not exposing anything about it to the outside world. Because your data access is also on the server, you can enjoy the benefits of caching and optimizations in the Java stack.

  • Vaadin Architecture Overview
  • Framework introduction

No need to implement REST services nor make RPC calls

You don't have to make any RPC calls from the client-side because the communication between browser and server is taken care of by the framework. Server-side architecture allows you to make secure requests through your data access layer without a requirement to expose anything through a remote service.

Java EE and Spring integration

Vaadin offers official extensions to easily integrate with JavaEE and Spring.
Spring Java 
@Theme("valo")
@SpringUI
public class MyUI extends UI {
  @Autowired
  private Greeter greeter;

  @Override
  protected void init(VaadinRequest request) {
    setContent(new Label(greeter.sayHello()));
  }
}
Java EE Java 
@CDIView(LoginView.VIEWNAME)
public class LoginView extends CustomComponent implements View {
public final static String VIEWNAME = "login";

  @Inject
  public LoginView(User user) {
    // ...
  }
}

No GWT compilation necessary

Although Vaadin is built on top of GWT, most of the time you spend on the server side code implementing your business logic and data access, which doesn't require GWT compilation at all. No more CPU fans spinning madly. If you use some GWT extensions available on Vaadin Directory, you have to compile those only once, or you can even rely on cloud compilation.

Core libraries and most of the extensions are under a Apache 2.0 license

Vaadin Core offers you the whole framework functionality and the vast number of community developed add-ons. Commercial tools and support options are available, if you so choose.

Almost 700 add-ons available with an open source license.

Because of easy and powerful extensibility, there are a multitude of community developed add-ons that extend Vaadin for more specialized functionality.

Stability and easy migration paths

Vaadin is a mature product with stable APIs. We offer 5 years of maintenance for major releases. Simple migration path has been available for each major release since 2002.

Vaadin Designer, a drag-and-drop UI tool

Easy and fast drag-and-drop tool for Eclipse and IntelliJ IDEA. Available in Pro and Prime subscriptions.

Active community

An impressive number of published add-ons and the number of people active in the Vaadin forums testify for the popularity of Vaadin among the developers.

Our services