We recently announced merging the Hilla framework into the Flow framework. This follow-up gives more detail on what will change in practice for current Vaadin users and where we're heading in the future.
Nothing changes for existing applications
Support for React remains. We will continue to support client-side rendering with React, React APIs for Vaadin's current and future UI components, client-side routing, stateless RPC endpoints, TypeScript generation based on Java types, and form binding based on metadata from those Java types. Support for integrating React components into server-side Flow views also remains.
Merging Hilla into Flow also doesn't mean that all of Hilla's 3rd party dependencies would become required for all Vaadin applications. Over time some Hilla features, such as generating TypeScript types for Java classes used by client-server integrations, may become available for use with Flow components. Integration on that level will be done without significant changes to the dependency tree.
There will be no breaking changes affecting application code in Vaadin 25 due to the new direction, but we might still do some packaging adjustments that could require small changes to pom.xml or build.gradle. All our recent major releases are supported for 15 years which in the case of Vaadin 25 extends until 2040.
Positioning and priorities change
The main change is related to how we position client-side views relative to server-side views and how we prioritize future development work. The most visible direct changes will be outside of the code but instead in what we emphasize on the vaadin.com front page, how the documentation is structured, how we present Vaadin at conferences, and so on.
Going forward, the primary way of using Vaadin is with server-side Java for the UI. We see a Java-only approach as the most productive way of building applications with a rich domain model and complex business logic that needs to be accurately represented in the UI without compromising security. But it's not the only way.
Many Vaadin applications have use cases where client-side UI logic is a natural choice. Common examples include views that must remain interactive while the user is offline, and views that must support hundreds of thousands of active users with minimal server requirements. It is essential that we provide first-class support for building some views in that way while benefitting from server-side views for the rest of the application.
Client-side views with React become an essential feature to supplement the primary server-side development model. It joins a group of essential features and integrations such as our server push functionality based on Atmosphere, and dependency injection support with Spring or CDI.
Summary
Our core competence is to take care of the web technologies so that you can focus on your own business domain. The most powerful way of doing that is by providing a server-side Java programming model that uses the web behind the scenes, while still allowing you to optimize by directly using web technologies when appropriate. We are now doubling down on that strength with a very clear message: server-side UI logic with Java is the primary way of using Vaadin, but not the only way. Client-side UI logic with TypeScript and React is fully supported and recommended for specific use cases.
As always, community input is essential to shaping our roadmap. I’ll host a YouTube live stream on Thursday, November 6 at 15:00 CET / 9:00 AM ET about the future of React and client-side UI development with Vaadin. Post your questions in advance, or bring them to the live chat, and join us on Thursday!