Platform UI connects application models to SWT controls and supplies the Eclipse workbench: views, editors, commands, perspectives, dialogs, data binding and E4 application services. Use JFace for reusable presentation components, and the workbench/RCP layers when building an Eclipse application. Native SWT widgets are maintained in a separate repository.
Layer map · Concepts · Quickstart · Example · Architecture reference
| Layer | Start here | Typical question |
|---|---|---|
| JFace | org.eclipse.jface | How does model input become viewer content, labels or selection? |
| Data binding | Core binding and SWT/JFace binding | Which observable, realm and owner controls an update? |
| Workbench / IDE | Workbench and IDE | Who owns an editor, view, site or selection service? |
| E4 model | Workbench model | How is application structure represented? |
| Commands | Core commands | Which command and handler define an action? |
| Tests / examples | tests/ and examples/ | Where is the smallest matching reproduction? |
- Viewer: exposes model input/selection through a control.
- Content / label provider: supplies model elements versus their presentation. Providers have replacement and disposal lifecycles.
- Workbench part: an editor or view managed by workbench services; its controls, listeners and resources still need a clear lifetime.
- Realm: the execution context for observable access and notifications; it is not permission to access arbitrary SWT widgets from a worker thread.
- Resource manager / registry: shared-resource ownership. Do not call SWT disposal directly on a resource borrowed from a JFace manager or registry.
- RCP: the Eclipse rich-client application platform; some bundles are reusable there while other bundles specifically serve the IDE.
This fork is an optimized, backward-compatible superset of Eclipse Platform UI. Existing applications written against the upstream subset must retain their public APIs and behavior when they use this fork. Fork-specific APIs, features, optimizations and contracts are part of the superset and must be preserved when changes are integrated.
Compatibility is directional: the fork supports existing subset clients; upstream is not required to implement the fork's extensions. Release qualification covers the inherited contracts and the additional fork behavior.
This fork derives from Eclipse Platform UI. The established JFace/workbench implementations and M3 sidecar coexist with a source-backed architecture and coverage guide. Its module/package inventory and selected lifecycle contracts are documented; complete per-package semantics and runtime qualification remain separate work. The M3 direction below is not a claim of measured responsiveness, memory savings or complete runtime integration in this checkout.
The inspected Jenkinsfile selects JDK 25. Prepare Maven 3.9.x, network access to Eclipse parent/p2 dependencies and a working SWT/native display. The Oomph setup below creates an upstream workspace; verify fork remotes before editing. Maven defaults configure individual-bundle/target resolution; a plain Java classpath is not the PDE target platform.
git clone https://github.com/hsoliwal/eclipse.platform.ui.git
cd eclipse.platform.ui
git rev-parse HEAD
java -version
mvn -version
# Focused JFace source-plus-test lane; not the whole repository.
mvn clean verify -pl :org.eclipse.jface,:org.eclipse.jface.testsUse mvn clean verify for the ordinary full reactor. Tycho's integration-test
lifecycle requires verify; a test invocation alone is not equivalent.
These commands were checked against source/configuration, not executed here.
git grep -n -e 'setContentProvider' -e 'setInput' -- bundles/org.eclipse.jface/src
git grep -n 'handleDispose' -- bundles/org.eclipse.jface/src/org/eclipse/jface/viewers
find . -path '*/target/surefire-reports/TEST-*.xml' -print- Include the modified production bundle alongside its tests so the selected run does not silently exercise only a target-platform copy.
- For a stale label, distinguish model mutation, provider notification and viewer refresh before modifying SWT painting.
- For shutdown failures, trace provider listeners, control disposal and delayed callbacks. A repaint cannot repair invalid ownership.
Replace a viewer's input without retaining the previous model. Read ContentViewer.java with the lifecycle guide.
- Create the viewer/control, install its content and label providers, then set input.
- In
setInput, the provider receives old/new input before the viewer stores the new input. Detach old-model listeners and attach new-model listeners there. - Keep that provider callback safe for teardown as well: input removal is also part of disposal. Do not assume it is always a normal presentation update.
- Provider replacement may dispose the old provider; sharing it across viewers requires an explicit shared-lifetime design.
- Test input A → input B → control disposal, checking that A no longer notifies this viewer and cleanup releases listeners. The homepage describes the case; it does not claim those tests were run.
Continue with JFace, data binding, RCP and the architecture coverage boundaries. The original project, contribution and licensing sections remain below.
Source tour checked at
119b433438c6. Commands describe that revision; recheck build configuration when changing revisions. Build/UI/performance verification was not run for this README update.
Test runtime ideas against the real IDE workbench—not only isolated microbenchmarks.
Note
This is an experimental downstream fork of the upstream Eclipse Platform UI project. M3 String, regex, precompute and collection integration are engineering directions, not verified deployment, performance, compatibility or upstream-endorsement claims. Preserve original licensing, copyright, API behavior and native/UI contracts.
| Surface | What to investigate | Non-negotiable contract |
|---|---|---|
| Workbench state | Measure lifecycle, selection, editor and view-state access | RCP/IDE extension points and public behavior |
| SWT handoff | Characterize event-loop responsiveness, model-to-widget transitions and native resources | Thread affinity, disposal and UI responsiveness |
| Long sessions | Reproduce open/edit/search/close cycles | No retained-state leaks or correctness regressions |
Approach: inventory first; copy/derive only with license and provenance; qualify reusable recipes in Synexia; port into the appropriate runtime/product owner; then test with representative desktop projects and publish CPU, allocation, retained-memory, startup and responsiveness numbers, including regressions. No Synexia runtime dependency.
Java, JNI, SWT, workbenches, widgets, real code: open the repositories. Bring a failing case, a performance counterexample, a profiler trace or a better algorithm. Challenge the design on the merits of source, tests and evidence—not slogans or a résumé.
Explore the family: M3JDK21 · SWT · Eclipse Platform · Platform UI · Nebula · GEF Classic.
Contribute here: issues · pull requests · M3 compatibility and benchmark contract.
The remainder of this README retains the existing M3 fork notes and the original upstream Eclipse Platform UI documentation. Nothing in this introduction rebrands upstream work as M3-authored code.
M3 is based on the idea that shared immutable structure and indexed metadata can provide a basis for reusable computation. The programme starts with M3 String, regex, and precompute in M3JDK21, then collections and SWT/Eclipse integration.
This Eclipse Platform UI fork is a target for evaluating qualified runtime and collection improvements in RCP and IDE workloads, including responsiveness and resource use.
Explore the idea: M3 technical design paper · Programme goals and roadmap. The paper explains the proposed architecture, cost tradeoffs, and evaluation plan. Readers are invited to examine the work and contribute representative workloads.
This section describes the direction of the hsoliwal fork. Upstream documentation follows below; upstream authorship, licenses, and project identity remain intact.
Thanks for your interest in this project.
Platform UI provides the basic building blocks for user interfaces built with Eclipse.
Some of these form the Eclipse Rich Client Platform (RCP) and can be used for arbitrary rich client applications, while others are specific to the Eclipse IDE. The Platform UI codebase is built on top of the Eclipse Standard Widget Toolkit (SWT), which is developed as an independent project.
For more information, refer to the Eclipse Platform project page and the Platform UI wiki page.
- JFace provides viewers, dialogs and actions; start with the JFace guide
- Core data binding and JFace data binding have different owners; see JFace data binding
- The workbench and IDE integration sit alongside the E4 workbench model; see the RCP guide and E4 RCP FAQ
- Commands, text infrastructure, and CSS styling have their own APIs and test owners
- tests/, examples/ and features/ are separate reactor areas declared in the root POM
SWT's native widget implementations are maintained in the separate SWT repository. A workbench or JFace regression should first be reproduced in its UI test bundle; a native-widget issue may need a smaller SWT reproduction.
The Oomph configuration below provisions the upstream Platform UI development workspace. Verify the Git remote and branch before editing this fork. Fork-specific changes belong in hsoliwal/eclipse.platform.ui pull requests; upstream changes follow CONTRIBUTING.md.
The architecture and coverage guide connects source-backed lifecycle contracts, project/module ownership, Java package and source-set coverage, and export boundaries. It pins the inspected source revision and keeps unreviewed semantics, generated or native boundaries, and unrun verification visible. Inventory coverage is reported separately from complete package/API documentation.
Contributions are most welcome. There are many ways to contribute, from entering high quality bug reports, to contributing code or documentation changes.
For a complete guide, see the CONTRIBUTING page.
Several test plug-ins have a dependency to the Mockito and Hamcrest libraries. Please install them by installing "Eclipse Test Framework" from the current release stream p2 repo.
Use Maven 3.9.x and the JDK selected by the checked-in Jenkinsfile, currently JDK 25, to reproduce this revision's CI. From the repository root:
mvn clean verify
Tycho tests need the verify lifecycle; mvn test alone is not an
equivalent test run. For example, to build JFace and its test bundle together:
mvn clean verify -pl :org.eclipse.jface,:org.eclipse.jface.testsThe source and tests are in bundles/org.eclipse.jface/ and tests/org.eclipse.jface.tests/. Include the changed production bundle when selecting tests so the run exercises your source changes, rather than only a bundle resolved from the target platform. A focused run does not cover other workbench, text or data-binding test bundles.
The root POM enables the UI harness and UI thread by default.
Provide a working native SWT/display environment; Jenkins uses Xvnc on Linux.
.mvn/maven.config enables the individual-bundle profile,
eager target resolution and tycho.localArtifacts=ignore. The parent and
target dependencies must be reachable in the configured Eclipse repositories;
a plain Java classpath is not a substitute for the PDE target platform.
Test reports are written under **/target/surefire-reports/TEST-*.xml.
When reproducing the Jenkins lane, also inspect its API analysis and compiler
reports: that lane uses maven.test.failure.ignore=true, so a successful
Maven process alone does not prove passing tests. Report the exact command,
JDK, OS/display backend and any skipped or unavailable UI coverage.
This project uses GitHub to track ongoing development and issues. In case you have an issue, please read the information about Eclipse being a community project and bear in mind that this project is almost entirely developed by volunteers. So the contributors may not be able to look into every reported issue. You will also find the information about how to find and report issues in repositories of the eclipse-platform organization there. Be sure to search for existing issues before you create another one.
In case you want to report an issue that is specific to this eclipse.platform.ui repository, you can find existing issues or create new issues within this repository.
Contact the project developers via the project's "dev" list.