Docs

Blog

Enterprise

Pricing

About

Schedule a demo

Modern UX for SWT & Eclipse RCP — Same Code. Instant Results. Web-Ready.

Replace your legacy SWT renderer with a modern, GPU-accelerated engine. Keep your Java code. Deploy to desktop and web. Go live in five minutes.

GitHub

Schedule a demo

100%

OF THE CODE REMAINS
UNCHANGED

99%

LOWER COST OF MODERNIZING
A LEGACY JAVA APP

95%

FASTER DELIVERY WITH
REDUCED TEAM LOAD

0%

MAINTENANCE OVERHEAD

12X

FASTER APPLICATION
MODERNIZATION

Evolve your app. Right now

Download our CLI and update your desktop application with a modern UX and/or instant web deployment. It will replace your JAR in a second, and you'll see the transformation instantly.

Download the CLI

Modernize SWT applications, Eclipse RCP projects, and other SWT-based frameworks. Automatically handles JAR replacement-the fastest way to get started.

 $ irm https://dl.equo.dev/evolve/cli/install.ps1 | iex

Selected OS: Windows (AMD64)

SHA256SUMS

Modernize your App

Run one of the CLI commands below to modernize your application and/or take it to the web. Pass a folder, ZIP, or DMG — the CLI automatically detects and replaces the SWT JAR.

 $ equo modernize --web path/to/your/app

💡 Run equo modernize --help to see all available options and examples

Rebrand and Theme Your App

Your modernized app reads its look and feel from a few properties. Pick the values below, paste the result into your app's launcher file, and restart. No code changes, no rebuild.

swt.evolve.force_theme

Theme variant: light or dark.

swt.evolve.show_theme_color_palette

Show the theme switcher (true) or hide it (false).

swt.use_swt_fonts

Use the app's SWT fonts and text colors (true) or the theme's (false).

swt.use_swt_colors

Use the app's SWT background colors (true) or the theme's (false). Text colors follow use_swt_fonts.

swt.evolve.preserve_icon_colors

Keep icons in their own colors (true) or tint them to the theme (false).

swt.evolve.disable_evolve_icons

Keep the app's own icons (true) or let Evolve substitute its set (false).

swt.evolve.decorations_align

Menu bar: vleft/vright fold it into a menu button at the left/right end of the toolbar; hleft/hright show it as a bar above the toolbar, left- or right-aligned.

swt.evolve.show_scaling_control

Show the scaling control (true) or hide it (false).

dev.equo.swt.mode

Run in the browser (web, the default) or as a native desktop app (desktop). Web mode writes no line.

 -vmargs-Dswt.evolve.force_theme=light-Dswt.evolve.show_theme_color_palette=true-Dswt.use_swt_fonts=false-Dswt.use_swt_colors=false-Dswt.evolve.preserve_icon_colors=true-Dswt.evolve.disable_evolve_icons=false-Dswt.evolve.decorations_align=vleft-Dswt.evolve.show_scaling_control=true

Live preview · illustrative In the browser

Your App ×

localhost:8080/yourapp

100%

yourapp src Main.java Editor.java Views.java resources icons plugin.xml build.properties MANIFEST.MF

Main.java plugin.xml

package com.example.yourapp; public class Main { public static void main(String[] a) { Display d = new Display(); Shell s = new Shell(d); s.setText("Your App"); new Views(s).create(); s.open(); while (!s.isDisposed()) { if (!d.readAndDispatch()) d.sleep(); } }}

💡 Add these lines after -vmargs in your app's .ini file (e.g. eclipse.ini), replacing any existing values.

View Documentation on GitHub →

Why this approach matters? (rewrite vs. Equo)

A ground-up rewrite shifts teams to a new stack, new logic, and a long, risky timeline. Equo preserves your codebase and skills, so engineering time goes to features your users see — not to re-implementing what already works.

	Keep Legacy SWT	Full Rewrite (new stack)	Equo
Time to value	N/A (no UX improvement)	Years	Weeks
Opportunity cost	High	High	Low
Upfront cost	Low	Very high (hire/retrain, dual-run)	Low-Medium
Delivery risk	Low	Very high (scope creep, rewrites)	Low
UX outcome	Outdated UI/UX	Modern, eventually	Modern now (GPU, animations, theming)
Cloud / Browser	No	Yes, but only after rewrite	Yes (browser mode without rewrites)
Talent / Skills	Keep Java	New stack + retraining	Keep Java
Security & compliance	Aging surface	Re-implement controls	Enterprise modules
Maintenance	Rising costs	New long-term burden	LTS, vendor supported

The Strategic Benefits of Modernizing with SWT Evolve

Drop-In UI Modernization

Upgrade to a modern interface by simply replacing the SWT library—no code rewrites or refactors required.

Cross-Platform Deployment

Deliver your Java desktop apps on Windows, macOS, Linux, and a modern web browser using the same codebase.

Built-In & Branded Themes

Apply built-in themes or unlock full brand identity customization with our enterprise option.

Free & Enterprise Option

Start with the open-source version, and scale with enterprise features when needed.

Built-in Accessibility Tools

Meet WCAG and compliance standards with included diagnostics, screen reader support, and audit tools — all available in the Enterprise edition.

Support for Modern Standards

Modern, community-driven standards with the reliability of guaranteed SLA and premium support in the Enterprise edition.

Migrate to cloud

“Web-ready” gets your SWT application running in the browser. Migration to Cloud goes further: it delivers your app as a centrally managed, secure, scalable service on AWS/Azure/GCP (or private cloud) while you keep the same Java/SWT codebase.

Why it matters?

Centralized ops, zero installs: IT ships one managed service instead of maintaining desktop installs. Updates roll out instantly to every user.

SaaS at your pace: Multi-user access, environments (dev/stage/prod), usage-based scaling, and regional deployments.

Faster releases: Plug into your CI/CD; ship UI and back-end changes with repeatable pipelines and rollbacks.

What you get? (beyond “web-ready”)

Cloud deployment model: Containerized JVM back end; SWT Evolve renders the application in the browser and connects via a secured real-time bridge.

Identity & access: SSO/OIDC/SAML, role-based access, audit logs.

Operations: Autoscaling, monitoring/metrics/logging, centralized config, backups/disaster recovery, WAF and network policy integration.

Governance: Data residency options, compliance/a11y tooling, signed artifacts and controlled release channels.

What changes vs. what stays the same?

Stays the same: Java business logic, SWT semantics (layouts/events), build tools (Maven/Gradle), tests, CI habits.

Evolves: Rendering target (browser), packaging (containers/K8s optional), identity/ops are centralized and policy-driven.

Outcome

You move from “an app installed on every desktop” to “a managed enterprise service”: easier to secure, simpler to scale, faster to update, and no code rewrite standing in the way of your roadmap.