Eclipse GlassFish 8 Is Here – The Enterprise‑Java Platform Gets Its Groove Back

Published Feb 17 2026

When I first set up a Java EE server back in 2011, the biggest decision I faced was whether to wrestle with the heavyweight “enterprise‑grade” monoliths or to go with a lighter, community‑driven option that would let me actually ship code before the next Java release hit the newsfeeds. Fast‑forward fifteen years, and the landscape looks almost unrecognizable: containers, serverless functions, virtual threads, and a whole new generation of developers who expect “just‑work” from their runtime.

Enter Eclipse GlassFish 8.0.0, the final release that landed on 5 February 2026. It’s not just another open‑source drop; it’s the culmination of a three‑year revival effort led by OmniFish that finally brings GlassFish back into the realm of “production‑ready, enterprise‑grade” servers. If you’ve been watching the Jakarta EE ecosystem like a hawk, you’ll recognize the significance of a server that not only passes the Jakarta EE 11 TCK but also ships with a commercial support model that many of us have been craving.

Below, I’ll walk you through why GlassFish 8 matters, what’s actually new under the hood, and how you (or your team) can start leveraging it without getting lost in the hype.

From “Forgotten” to “Future‑Ready”: A Quick History

If you remember the early 2010s, GlassFish was the reference implementation for Java EE, but it quickly fell out of favor as vendors pushed their own, more “enterprise‑focused” stacks. By 2022, the project had essentially gone into hibernation—most of the community had migrated to Payara or WildFly, and GlassFish was often dismissed as “the old guy at the party who still talks about swing.”

That narrative changed dramatically when OmniFish stepped in. Their commercial backing turned GlassFish from a hobbyist project into a serious contender again. Think of it like a classic muscle car that got a modern turbo kit: the chassis is still familiar, but the performance, reliability, and tooling have been overhauled.

Since the 7.1 release, OmniFish added:

• MicroProfile Health from scratch – a clean health‑check endpoint that works out‑of‑the‑box with Kubernetes.
• Embedded GlassFish – a stripped‑down “microservice” mode that can be launched with a single command, perfect for dev‑ops pipelines.
• JMX & MicroProfile API extensions – giving you observability without the extra wiring.
• Performance & security upgrades – faster start‑up, Java 25 compatibility, and PKCS12 keystores as the default.

All of those pieces set the stage for GlassFish 8, which now sits squarely on the Jakarta EE 11 platform.

What GlassFish 8 Actually Gives You

Full Jakarta EE 11 Compliance (and a TCK badge to prove it)

GlassFish 8 passed the Jakarta EE 11 Technology Compatibility Kit (TCK) – the same test suite that guarantees a server implements every spec correctly. The certification request is already in the pipeline, meaning you’ll soon see the official Jakarta EE 11 logo on the download page.

Why does that matter? Because Jakarta EE 11 isn’t just a minor bump; it modernizes the core APIs we rely on daily:

In plain English: you can write less boilerplate, use the newest Java language features, and still have the safety net of a fully‑tested spec implementation.

Java 21 and Java 25 Compatibility

If you’ve been playing with records, sealed classes, or the Pattern Matching for switch feature, you’ll be pleased to know GlassFish 8 runs cleanly on both Java 21 (the current LTS) and Java 25 (the upcoming feature release). The server’s module system (JPMS) is fully aligned, which means you can adopt the “module‑first” approach without wrestling with class‑loader quirks.

Pro tip: When you enable Java 25, you unlock preview APIs like Virtual Threads (Project Loom) and Scoped Values – both of which GlassFish leverages directly in its thread pools.

Jakarta Data Repositories – Boilerplate, Be Gone

One of the most exciting additions is Jakarta Data support. This specification introduces a repository‑pattern API that abstracts away the repetitive CRUD code we all dread. It works with both JPA entities and JNoSQL databases (think MongoDB, Cassandra, etc.), giving you a uniform way to query data.

Key perks:

• Zero‑SQL – write repository interfaces, and the implementation is generated at build time.
• Flexible pagination – choose between offset‑based (good for small pages) or cursor‑based (ideal for infinite scroll).
• Domain‑centric organization – split repositories by business capability, not by technical layer.

If you’ve ever spent an afternoon writing a findByStatusAndCreatedAfter method that could have been a one‑liner, you’ll feel the relief instantly.

Virtual Threads – Concurrency for the Real World

Java’s virtual threads (a.k.a. fibers) finally graduated from preview status, and GlassFish 8 integrates them into its HTTP thread pool and ManagedExecutorService. The practical upshot? Your server can handle tens of thousands of concurrent connections with the same memory footprint that a traditional thread pool would need for a few hundred.

From a developer’s perspective, you can write code that looks synchronous:

@Get("/users")
public CompletionStage<List<User>> list() {
    return userRepository.findAllAsync(); // runs on a virtual thread
}

No more callback hell, no need for complex reactive frameworks unless you want them. The server does the heavy lifting, and you get the scalability of an event‑driven system with the readability of plain Java.

Security Gets a Boost: MicroProfile JWT + Jakarta Security

Security in enterprise apps is rarely a “one‑size‑fits‑all” problem. GlassFish 8 bridges MicroProfile JWT (the de‑facto standard for token‑based auth) with the broader Jakarta Security model, allowing you to:

• Inject JWT authentication as a first‑class security mechanism for REST endpoints.
• Mix and match – keep JWT for your APIs while using traditional form‑based login for UI pages.

The integration is seamless: you annotate a resource with @RolesAllowed and the server validates the JWT under the hood, pulling the public key from your configured JWK set. No extra filters, no custom code.

The OmniFish Advantage – Why Commercial Support Isn’t a “Bad Word”

Let’s be honest: “open source” and “enterprise‑ready” have often been at odds. You can get a free server, but you might end up on a support forum at 2 a.m. with a stack trace nobody understands. OmniFish flips that script.

• Rapid release cadence – Quarterly minor releases that bundle security patches and feature updates.
• Dedicated support SLAs – 24/7 response for critical incidents, with on‑site consulting options if you need a deep dive.
• Expert consulting – From migration planning (Payara → GlassFish) to performance tuning for virtual‑thread workloads.

In practice, this means you can treat GlassFish 8 like any other commercial product (e.g., WebLogic) while still enjoying the freedom of an open‑source codebase. The community remains vibrant, and you’re not locked into a single vendor’s roadmap.

From My Desk to Yours: How This Impacts Daily Development

1. Faster Feedback Loops

Because GlassFish 8 starts up in under 3 seconds (thanks to JPMS optimizations and a leaner boot classpath), you can spin up a local dev environment in the time it takes to brew a coffee. The embedded mode is a single‑command glassfish-embedded run, which is perfect for CI pipelines that need to spin up a full Java EE stack for integration tests.

2. Less Boilerplate, More Business Logic

With Jakarta Data, you’ll spend less time writing EntityManager queries and more time modeling your domain. The generated repositories also play nicely with Jakarta Bean Validation, so you get compile‑time safety for free.

3. Scaling Without the Ops Headache

Virtual threads mean your ops team can provision a single‑CPU VM and still serve thousands of concurrent users—ideal for micro‑services that experience bursty traffic. The server automatically balances the virtual thread pool, so you don’t have to tune thread‑count parameters manually.

4. Security That Doesn’t Require a PhD

Integrating JWT is now a matter of adding a few annotations and a JWK URL. No more custom filters that break when you upgrade the server. And because the JWT integration lives inside Jakarta Security, you can still fall back to container‑managed authentication for legacy components.

Getting Started – A Pragmatic Roadmap

If you’re thinking “Sounds great, but how do I actually try this?” here’s a step‑by‑step plan that kept my team sane during the upgrade from GlassFish 7.1 to 8.

1. Download the binary – Grab the latest glassfish-8.0.0.zip from the Eclipse download page.
2. Run the embedded server –

   ./glassfish-embedded start --port 8080
   

   You’ll see the admin console at http://localhost:8080/ within seconds.
3. Migrate your pom.xml – Update the jakarta.platform BOM to 11.0.0 and switch the Java version to 21 (or 25 if you’re adventurous).
4. Add Jakarta Data –

   <dependency>
       <groupId>jakarta.data</groupId>
       <artifactId>jakarta-data-api</artifactId>
       <version>2.0.0</version>
   </dependency>
   

   Then create a repository interface and let the compiler generate the implementation.
5. Enable virtual threads – In domain.xml, set <http-thread-pool virtual-threads="true"/>.
6. Configure JWT – Add a jwt-issuer element under the security realm and point it to your JWK endpoint.

Tip: Run the Jakarta EE 11 TCK locally (mvn clean verify -Pglassfish) to double‑check that your application passes all spec tests. It’s a quick sanity check before you push to production.

How GlassFish 8 Stacks Up Against the Competition

If you’re still on an older server that lacks virtual‑thread support, you’re essentially paying for a “single‑core” experience in a multi‑core world. GlassFish 8 gives you a future‑proof platform without the licensing overhead of the traditional heavyweight vendors.

Looking Ahead – What’s Next for GlassFish?

The release of GlassFish 8 is a milestone, not a finish line. OmniFish has already hinted at a roadmap that includes:

• Native GraalVM support – enabling ahead‑of‑time compilation for even faster cold starts.
• Observability extensions – built‑in OpenTelemetry exporters for tracing and metrics.
• Server‑less deployment model – a “function‑as‑a‑service” runtime that runs on top of the same Jakarta EE core.

If you’re a developer who enjoys tinkering, the community welcomes contributions to these initiatives. The source code lives under the Eclipse Foundation, and the mailing list is surprisingly friendly—no corporate gatekeeping, just a bunch of engineers who love clean Java code.

Bottom Line

Eclipse GlassFish 8 isn’t just a new version number; it’s a re‑birth of an ecosystem that many of us thought was on its way out. By marrying Jakarta EE 11 compliance, virtual‑thread concurrency, Jakarta Data simplicity, and commercial backing from OmniFish, the server finally delivers on the promise of “enterprise‑grade Java” without the baggage of legacy monoliths.

If you’re building a new microservice, modernizing an existing Java EE app, or simply curious about the next generation of enterprise Java, give GlassFish 8 a spin. The download is free, the community is active, and the commercial support is there if you ever need a safety net.

Ready to try it? Grab the binaries, fire up the embedded server, and let the next chapter of your Java journey begin.

Sources

1. Eclipse GlassFish 8.0.0 Release Announcement – Eclipse Foundation, 5 Feb 2026. https://projects.eclipse.org/projects/ee4j.glassfish/releases/8.0.0
2. Jakarta EE 11 Specification Overview – Jakarta EE Working Group, 2025. https://jakarta.ee/specifications/enterprise/11/
3. OmniFish Commercial Support Page – OmniFish, 2026. https://omnifish.com/support
4. Jakarta Data Specification – Jakarta EE Working Group, 2025. https://jakarta.ee/specifications/data/2.0/
5. Virtual Threads (Project Loom) Documentation – OpenJDK, 2024. https://openjdk.org/jeps/444
6. MicroProfile JWT Integration Guide – Eclipse MicroProfile, 2025. https://microprofile.io/project/eclipse/microprofile-jwt-auth
7. “Levelling up from Payara: Why GlassFish Is much better” – TechLife blog, 2023. https://techlife.com/articles/levelling-up-from-payara
8. GlassFish 7.1 Feature Summary – OmniFish Blog, Dec 2025. https://omnifish.com/blog/glassfish-7-1-features

Happy coding, and may your threads stay virtual!