Look, if you're starting a new Java web project in 2026, you should probably just use Spring Boot. With 14.7% usage in the 2025 Stack Overflow Developer Survey and a 53.7% admiration score among all web frameworks, it remains the default choice for modern Java web development. It has the largest ecosystem, best documentation, most active community, and strongest cloud-native support—now enhanced with built-in AI capabilities through Spring AI.
That said, there are specific scenarios where you might consider other frameworks. Quarkus has matured significantly and deserves serious consideration for microservices and serverless deployments, offering sub-second startup times and minimal memory footprints. Micronaut is another cloud-native option worth evaluating for memory-constrained environments. Jakarta Faces (formerly JSF) still makes sense if you're deeply invested in the Jakarta EE ecosystem. GWT can be valuable if your team wants to write frontend code in Java instead of JavaScript. Vaadin shines for internal business applications where rapid UI development trumps customization. Play Framework deserves consideration if you're building reactive systems, as its architecture is specifically designed for high-concurrency and real-time applications. While these frameworks may have smaller communities than Spring Boot, they excel in their specific use cases.
Below, we'll examine what makes each of these frameworks uniquely valuable, starting with the dominant Spring ecosystem.
Spring
Project Site: https://spring.io/
Primary Sponsor: VMware/Broadcom
Spring is more than just a web framework. It is a complete programming model that is built on and with Java, starting with Spring Boot, which is a way to get a Spring application up and running with minimal configuration and no application server required. At the other end of the spectrum is Spring Cloud, which is a combination of components that allows developers to build resilient and reliable cloud-native applications that leverage the latest distributed patterns like a microservices architecture—two examples include application security and batch processing.
Spring Boot 4.0 was released in November 2025, bringing complete codebase modularization, JSpecify null-safety annotations, and first-class Java 25 LTS support. However, Spring Boot 3.5.x remains the current production recommendation for most teams, offering stability while the 4.0 migration patterns mature. Spring Boot continues to be the most widely adopted Java framework in enterprise environments.
A significant addition to the Spring ecosystem is Spring AI 1.0, launched in May 2025. This brings native LLM integration with support for 20+ AI models and Model Context Protocol (MCP), making Spring Boot attractive for teams building AI-enabled applications.
Getting started with Spring is as simple as going to Spring Initializr and selecting the build framework you desire and any and all the Spring projects you want included in the initial application. It will create the Maven or Gradle configuration and all the basic Spring configuration required to start.
Creating a simple web application starting with Initializr:
… which will create a Zip file with the following files in it:
./mvnw.cmd
./pom.xml
./.gitignore
./.mvn/wrapper/maven-wrapper.properties
./.mvn/wrapper/maven-wrapper.jar
./mvnw
./src/test/java/com/example/demo/DemoApplicationTests.java
./src/main/resources/application.properties
./src/main/java/com/example/demo/DemoApplication.javaYou need a Controller — src/main/java/com/example/demo/DemoController.java:
package com.example.demo;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class DemoController {
@RequestMapping("/hello")
public String hello() {
return "hello";
}
}And a template file — src/main/resources/templates/hello.html
<!DOCTYPE HTML>
<html>
<head>
<title>Hello World</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>
<p>Hello World</p>
</body>
</html>Quarkus
Project Site: https://quarkus.io/
Primary Sponsor: Red Hat
While Spring Boot dominates traditional enterprise development, Quarkus has emerged as a compelling alternative for cloud-native and serverless deployments. Optimized for Kubernetes and containerized environments, Quarkus achieves sub-10ms native startup times with GraalVM, making it ideal for serverless functions and microservices that need to scale quickly.
Quarkus offers seamless integration with Kubernetes, reactive programming with Mutiny, and live coding with instant reload for rapid development cycles. It supports modern Java features and provides excellent developer experience with extensions for most popular Java libraries and frameworks. The framework has gained significant traction with the larger community and ecosystem among cloud-native Java frameworks.
Micronaut is worth mentioning as an alternative in this space. Backed by Oracle, it excels in memory-constrained environments through its compile-time dependency injection, eliminating reflection overhead. It's lighter than Quarkus in terms of memory usage and offers excellent support for serverless functions, making it ideal for AWS Lambda and similar platforms.
Choose Quarkus for Kubernetes-first deployments and when you need a larger ecosystem of extensions and community support. Consider Micronaut for extreme memory efficiency and AWS Lambda deployments. For traditional enterprise applications with complex requirements, Spring Boot remains the safer choice.
Jakarta Faces (formerly JSF)
Project Site: https://jakarta.ee/specifications/faces/
Primary Sponsor: Eclipse Foundation
Jakarta Faces (formerly known as Java Server Faces or JSF) is a specification for displaying web user interfaces that is defined as part of the Jakarta EE Platform (formerly Java Platform, Enterprise Edition).
The current version, Jakarta Faces 4.1, was released as part of Jakarta EE 11 in 2025. The framework is component-based, allowing it to be expanded with additional components. IceFaces and MyFaces are two popular add-on components.
As Jakarta Faces is part of the Jakarta EE standard (now fully under the Eclipse Foundation), it appeals to teams that prefer official specifications over third-party frameworks, ensuring compatibility across different Jakarta EE application servers. Jakarta Faces also allows existing backend Java code to be extended with a web interface without having to refactor the base application by introducing a new framework.
A simple Jakarta Faces application requires a Managed Bean, Facelet, and mapping the servlet.
helloworld.java
package helloworld;
import jakarta.faces.bean.ManagedBean;
@ManagedBean
public class HelloWorld {
final String world = "Hello World!";
public String getworld() {
return world;
}
}helloworld.xhtml
<html lang="en"
xmlns:h="http://jakarta.ee/xml/ns/jakartaee">
<h:head>
<title>Facelets Hello World</title>
</h:head>
<h:body>
#{hello.world}
</h:body>
</html>web.xml
<servlet>
<servlet-name>Faces Servlet</servlet-name>
<servlet-class>jakarta.faces.webapp.FacesServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>Faces Servlet</servlet-name>
<url-pattern>/faces/*</url-pattern>
</servlet-mapping>GWT (Google Web Toolkit)
Project Site: http://www.gwtproject.org/
Community Maintained
GWT is much like Jakarta Faces in that it is strictly focused on building web interfaces. It makes it easy to maintain complex JavaScript user interfaces with Java code. The current version is GWT 2.12, released in 2025 with support for Java 12-17 language features including records and pattern matching.
It's worth noting that GWT is now community-maintained with minimal Google involvement. Google's strategic successor is J2CL (Java-to-JavaScript transpiler), which is used in production by Gmail, Google Docs, and Calendar. For new projects, teams should carefully evaluate whether GWT's community support meets their long-term needs.
GWT has lost some of its popularity over the last couple of years as more development teams are pushing Java to the backend and having it expose REST APIs which are consumed by both native mobile apps and user interfaces built in Node.js, using frameworks like Angular.
A tutorial on how to build a simple GWT application can be found on its project site: Getting Started building a GWT app.
Play Framework
Project Site: https://www.playframework.com/
Community Maintained
Play is an open-source framework for Java and Scala built around asynchronous, non-blocking architecture, making it well-suited for applications that handle many concurrent connections. It follows the MVC design pattern and contains inbuilt features such as code reloading and convention over configuration.
Play Framework 3.0 represents a significant milestone, completing the migration from Akka to Apache Pekko (the community fork of Akka). This ensures fully open-source licensing going forward. Teams using Play 2.x should plan migration to 3.0 to avoid potential licensing complications with end-of-life Akka versions.
Play provides minimal resource consumption, and is high performance due to asynchronous processing. It enables building scalable, modern web and mobile applications. It also boasts high reliability, flexibility and security features. The framework is now community-maintained following changes in Lightbend's support model.
Struts
Project Site: https://struts.apache.org/
Struts is an open-source Java EE framework used for creating enterprise-level Java web applications. Development is much easier with Struts since it uses the MVC pattern and convention over configuration. The MVC pattern also enables clean designs that are easy to implement. Struts is easy to set up and provides much more flexibility and extensibility over traditional MVC using servlets and JSP.
The current version is Struts 7.1, released in October 2025. Struts continues to receive active maintenance from the Apache Software Foundation, with regular security updates and feature enhancements.
Struts has a plugin-based architecture and it comes with plugins for REST, AJAX, Config Browser and JSON. It can be easily integrated with other Java frameworks like Spring and Hibernate. Due to its rich functionalities, it is one of the most preferred frameworks for developing enterprise-level applications. However, teams should stay current with security patches and carefully evaluate migration paths for aging Struts applications.
Vaadin
Project Site: https://vaadin.com/
Vaadin is an open-source Java web framework with an active community. It allows developers to build complex, dynamic and interactive applications using pre-designed UI components. Developers can create rich layouts and UIs without having to write HTML, CSS and JavaScript.
Vaadin 25.0, released in December 2025, represents a major modernization of the framework. It introduces the new Aura theme, Tailwind CSS support, and Vaadin Copilot—an AI-powered development assistant that replaces the deprecated Vaadin Designer. The framework now includes Vaadin Signals for reactive state management and requires Java 21+ as a baseline. Breaking changes include the merger of Hilla into Flow as an opt-in dependency and mandatory Spring Boot 4/Framework 7 for Spring projects.
Vaadin provides a server-side architecture that contains several useful features such as Data Binding APIs, automated routing and client-server communication. These features allow developers to focus on the presentation layer only. The platform continues to be an excellent choice for rapid development of internal business applications where developer productivity and type-safety are priorities over extreme customization.
Grails
Project Site: https://grails.org/
Primary Sponsor: Apache Software Foundation
Grails is a dynamic Java web framework that is based on the MVC design pattern. It is written in Groovy but is perfectly compatible with Java syntax and runs on the Java platform. It is a full-stack framework with built-in support for REST APIs.
In October 2025, Grails graduated to become an Apache Software Foundation top-level project, providing long-term governance stability. The current version is Apache Grails 7.0, which requires Groovy 4.0, Spring Boot 3.5, and Java 17+ as minimum requirements. The 6.x line has reached end-of-life due to Spring Boot 2.7.x deprecation.
Grails comes with several useful features such as an extensive library of plugins, dynamic formation and object mapping. It is also very developer-friendly and comes with detailed, high quality documentation and step-by-step guides. Grails follows several modern software development principles such as convention over configuration, opinionated APIs and sensible defaults.
Hibernate
Project Site: https://hibernate.org/
Primary Sponsor: Red Hat, Inc.
Hibernate is a stable and mature ORM tool that can easily communicate with any database and therefore makes handling them with Java much easier. It is easy to scale up, configure and customize.
Hibernate ORM 7.0, released in May 2025, marks a major milestone with a license change from LGPL to Apache 2.0, enabling broader adoption across the Apache and Jakarta ecosystems. This version fully implements Jakarta Persistence 3.2 and the new Jakarta Data 1.0 specification, bringing repository-style data access patterns to the standard platform. The current version is Hibernate 7.2 (December 2025), which adds vector support for SQL Server and enhanced read-only replica capabilities.
Hibernate provides powerful APIs and several useful tools that provide a smooth experience for developers. While it is not a fully independent framework, its support of object-level relationships and an abstraction layer for interacting with databases make it a popular choice for Java developers.
The Bottom Line on Java Web Frameworks
If you're starting a new project, Spring Boot should be your default choice unless you have a compelling reason to choose another framework—such as serverless scale-to-zero requirements (Quarkus), extreme memory constraints (Micronaut), or specific architectural needs (reactive systems with Play). Whatever you choose, remember that major version migrations (Spring Boot 3→4, Hibernate 6→7, Jakarta EE 10→11) are active considerations in 2026, so carefully evaluate your team's requirements and long-term maintenance needs before committing.
If you haven't already, signup for a 14-day free trial of Rollbar and let us help you catch and fix Java errors before they impact users. 🙂
