Equo 2025: Year in Review
Gabriel Beghelini on December 18th 2025
This is our annual year-end update, where we look back at what we built and what’s next.
As 2025 wraps up, we’re taking a step back to show the full arc of Equo’s evolution throughout 2025: what changed in our products, how far we’ve come, and what’s ahead in 2026.
If you’ve followed Equo for a while, you’ll recognize key milestones. If you’re new here, this is the fastest way to understand what Equo is becoming: a modern foundation for legacy Java desktop applications that require easy solutions and features for improved functionality, performance, and experience without compromising what makes them mission-critical.
A quick note before we start
In 2025, Equo doubled down on modernizing long-lived desktop software, introducing a modern UI, embedded web, and a safer path to adoption in real-world products without disrupting existing workflows.
We worked on two parallel tracks:
1. Enhance Equo Chromium's strength across toolkits and platforms.
2. Turn SWT Evolve from an early concept into a real product with a clear direction, practical capabilities, and a roadmap that’s now measurable.
Below you’ll see:
- Where our products started the year.
- The goals we set.
- The obstacles we had to solve early.
- What we delivered by the end of 2025.
- And where we’re going in 2026.
Where we were in early 2025
Product reality at the start of the year
At the beginning of 2025, Equo Chromium was already powering thousands of embedded web experiences for Java desktop applications, but the focus was on expanding functionality, consistency, and toolkit coverage.
- Equo Chromium: solid foundation, strong momentum, and clear demand from teams embedding web UIs inside SWT/Swing/Eclipse RCP applications.
- SWT Evolve: at that time, it was still in early development, a working direction with initial prototypes and feasibility work, but not yet a packaged product with defined releases, documented scope, or a stable feature set.
In other words, we had a proven embedded browser foundation and a modernization vision that still needed to become real.
What we aimed for
We started 2025 with a clear internal challenge: build modernization technology that is realistic for teams with long-lived, mission-critical desktop software.
Our objectives looked like this:
Technical goals
- Strengthen Chromium performance and OS-level integration across toolkits.
- Move SWT Evolve from concept → usable developer experience.
- Establish a path where modernization doesn’t require rewriting entire UIs.
Commercial goals
- Make it easier for teams to adopt Equo with confidence (clear packaging, clearer offerings, better messaging).
- Make it clear how each technical improvement helps customers in real terms: faster UI, better UX, fewer issues, and more ways to ship.
The early obstacles we had to solve
Early on, the work wasn’t just “adding features.” We had to focus the scope so we could ship something real, while still keeping the long-term vision intact. That meant being precise about what “drop-in” and “compatible” should actually mean in day-to-day use, making behavior predictable across operating systems and UI toolkits, and building a foundation that modernizes the UI without breaking the workflows teams rely on.
That early constraint-solving is what made the second half of the year possible.
What we shipped and what changed by the end of 2025
SWT Evolve: concept → product (the biggest change of 2025)
The largest shift this year is simple:
SWT Evolve became real.
SWT Evolve is our modernization path for SWT/Eclipse RCP applications: a binary-compatible, drop-in SWT replacement designed to modernize the UI layer while preserving existing Java code and workflows.
What that unlocks:
SWT Evolve is the “before and after” moment for Equo in 2025.
Because it changes the question from:
“Can we modernize this legacy SWT/Eclipse RCP application without compromising it’s logic?” to: “How fast do we want to modernize it, and how far do we want to take it?”
Learn more about SWT Evolve with this blogs:
- The True Future of Eclipse RCP: Beyond the Rewrite
- Legacy vs Evolve
- First SWT Evolve FAQ! Clearing Up the Most Common Misunderstandings
SWT Evolve in the real world: modernization across industries
SWT and Eclipse RCP exist across industries where software lives for years and across a broad ecosystem of tools that teams rely on every day:
- Engineering & design tools.
- Embedded development environments.
- Healthcare, clinical systems & regulated desktop suites.
- IDE/Testing-based tools.
- Data analytics workbenches.
- Finance, trading & market operations desktops.
- Configuration suites, profilers, and visualization-heavy desktop tooling.
- Enterprise engineering platforms.
- Telecom & networking: test, monitoring, and lab automation.
- Long-lived internal tools where reliability matters more than trend-chasing.
- Automotive engineering: diagnostics, calibration & validation platforms.
We’re seeing SWT Evolve become a practical modernization layer for teams that can’t “just rewrite” their product and don’t want to risk destabilizing it.
In practice, teams are using SWT Evolve to upgrade the look and feel of existing SWT/Eclipse RCP applications while keeping the same Java codebase and workflows intact. Instead of starting a multi-year rewrite, they are modernizing instantly.
For many teams, SWT Evolve becomes the “safe path” to modernization, one that respects what already works, while removing the UI limitations that have accumulated over years of growth.
Equo Chromium: a year of stronger integration and performance momentum
While SWT Evolve was becoming a product, Equo Chromium kept moving forward aggressively. We started the year with version 128.0.7, and even though we were already a few releases into this, at the time, a new major version, there was still a lot of room for improvements in performance and stability.
Across 2025, we focused on the things that matter most for embedded browsers inside desktop tools:
- Better OS-level behavior and window integration.
- APIs that reduce toolkit-specific hacks.
- A smoother experience for developers embedding web UI inside SWT/Swing/Standalone applications.
During the year, we released our new major: 138. This release brought a whole new set of features and improvements, turning it into an extremely stable new major that only keeps getting refined. Furthermore, we kept working on our 128 release, perfecting it and making it surpass our standards of high performance and consistency, and seamless experience.
If you followed our release notes and blogs, you saw major improvements land, especially around window management and event handling APIs.
Here are some blogs on Equo Chromium’s 2025 trajectory:
Equo Enterprise: for teams that can’t take risks
As Equo grew in 2025, one thing became clear: Open Source is perfect to start but many teams need more than a library when the software they’re modernizing is business-critical.
Equo Enterprise is built for teams that need modernization with guarantees. It combines Equo Chromium + SWT Evolve with the structure and support required to adopt them safely in production.
Who benefits most
- Teams maintaining mission-critical SWT/Eclipse RCP or Swing desktop applications.
- Teams are blocked by outdated web-embedding technology and are unable to adopt modern standards safely.
- Products with long lifecycles that require planned updates and long-term maintenance.
- Applications that rely on domain-specific or custom views and need a modern, high-performance UI layer without rewrites.
- Engineering teams that need a safe, immediate modernization path without risking time, budget, and product stability by falling into a “bet-the-company” rewrite.
What you get
- End-to-end modernization.
- Engine updates < 1 week.
- Web deployment.
- Priority support and technical guidance during adoption and rollout.
- Predictable maintenance and upgrade paths.
- Long-term stability commitments for production deployments.
- Cross-platform support (Windows, MacOS, Linux).
- Security and deployment confidence, including help with handling enterprise rollout constraints.
- Equo SDK modules.
- A coherent package: Equo Chromium + SWT Evolve working together as a modernization stack, not isolated components.
Where Equo goes from here
What has a date attached (near-term)
- SWT Evolve official release target: End of January 2026 This is the milestone we’re driving toward: making SWT Evolve not just impressive, but officially “ready” as a product that teams can bet on.
- More Chromium + SWT enhancements: continued work on performance tuning, stability, and deeper OS-level integration, informed directly by customer workloads. This includes early improvements to our subscription-management API, significant groundwork for our upgrade to Chromium 144, a major step that brings broad security improvements, updated web standards, better performance across modern workloads, and a longer stability horizon for enterprise applications, and initial test support for GTK4 on Linux.
Beyond these enhancements, Equo Chromium is also evolving into a powerful alternative for teams that rely on web-driven desktop frameworks to deliver modern UI at scale. Its architecture brings the full expressiveness of the web into native applications without the overhead traditionally associated with JavaScript-centric runtimes. By combining a modern Chromium engine with the performance, memory efficiency, and data-handling strengths of the JVM, Equo Chromium offers a significantly more robust foundation for applications with large or complex back-end workloads. This opens a new path forward, one where teams can achieve a modern, web-rich experience while retaining the reliability and operational advantages of a Java-based technology stack using Equo Chromium as a powerful elemental tool.
- Chromium Standalone: Full standalone mode with complete window management and native OS integration.
- Chrome-Style Browser Features:
- Revitalizing Eclipse (Mid March 2026): Apply Equo’s products to upgrade the Eclipse IDE, so the platform stays up to date, improving UI responsiveness and visuals with SWT Evolve. This effort isn’t just about the IDE itself: it helps lift the entire Eclipse ecosystem, raising the baseline for the huge number of SWT/Eclipse RCP applications built on top of Eclipse and relied on every day across industries. The goal is to make Eclipse feel modern again, while keeping its strengths: stability, extensibility, and developer workflows.
- “We need a more modern UI, but rewriting is too risky.”
- “We want embedded web capabilities that behave like production software.”
- “We need a path from desktop to something more flexible over time.”
Growing the Equosystem
SWT Evolve isn’t the finish line, it’s the starting point.
Our goal is to grow an Equosystem where modernization is a practical toolkit teams can adopt step by step. That means building open source developer tools meant to help developers build new applications from the ground up in SWT and Eclipse RCP environments, not only modernize existing ones. In fact, through our Enterprise path, we are already modernizing long-lived desktop software across industries like engineering and design tools, embedded development environments, and data analytics workbenches, with long-term support and a more governed, production-ready way for teams to adopt and operate modernization at scale.
For teams that want to take modernization further, that same path includes Migrate to Cloud, which goes beyond “web-ready” by delivering the same Java and SWT application as a centrally managed, secure, scalable service on AWS, Azure, GCP, or private cloud. IT ships one managed service instead of maintaining desktop installs, and updates roll out instantly to every user. The goal is a platform that helps teams operate these migrated applications in one place: centralized deployments and updates, environments like development, identity and access controls such as SSO and role-based permissions, and the operational layer required for real production use, including monitoring, logging, autoscaling, governance, and controlled release channels. The outcome is moving from “an application installed on every desktop” to “a managed enterprise service” with centralized control over security, updates, and operations.
As we look ahead, our momentum doesn’t slow down. With Equo Chromium and SWT Evolve as the foundation of today’s modernization story, we’re committed to expanding the Equosystem with even more open-source developer tools that enable developers to innovate.
We’ll also be sharing more of this work publicly as it takes shape, including at OCX 2026, where the Equo team will be attending.
Final thoughts
We started 2025 by strengthening Chromium and shaping an idea. We’re ending 2025 with SWT Evolve as a real product and a clear modernization path. And we’re entering 2026 ready to ship an official release and expand the Equosystem further.
If you’re responsible for a Java desktop application built on SWT/Eclipse RCP (or Swing) and you’ve been thinking:
…then let’s talk.
Thanks for following Equo in 2025. See you in 2026!
— The Equo Team
