What Are RCP Components? A Clear Guide to Eclipse RCP Architecture

A modular Java desktop framework called Eclipse Rich Client Platform assembles full applications from small, independently versioned bundles rather than one monolithic codebase, and those bundles form the layered building blocks behind every RCP component. Plug-ins snap together through published contracts, the OSGi runtime (Equinox) keeps their classloaders isolated, and SWT/JFace plus the Workbench give you the pixels and window chrome on top. Knowing these layers pays off the moment you need to add a feature, swap a view, or ship a stripped-down product.

This walkthrough explains each layer in plain terms, shows how plug-ins talk through extension points, and walks through packaging and trade-offs so you can decide whether RCP fits your next desktop project.

The Modular Foundation of a Rich Client Platform

At its core, RCP is a Java desktop framework layered on three cooperating technologies: OSGi for module isolation, SWT/JFace for the native widget toolkit, and the Eclipse Workbench for the window, perspective, and part lifecycle. That division of labor is what makes the platform feel more like a runtime than a library. Drop a new plug-in into the directory and the running application discovers it, wires it in, and tears it down cleanly when you remove it.

Plug-Ins as the Smallest Deployable Unit

A plug-in is a bundle, which means it is a JAR file with a MANIFEST.MF that declares its name, version, required dependencies, and the packages it exports. Because each bundle has its own classloader, two plug-ins can ship different builds of the same library without colliding. That isolation is the single biggest behavioral difference from a standard Java application, where the system classloader flattens everything onto one classpath.

Equinox and the OSGi Runtime

Eclipse ships with a specific OSGi container called Equinox that manages bundles, services, and lifecycle events across the platform. It reads each bundle’s manifest, resolves the dependency graph, and starts plug-ins in an order that respects their lifecycle states (INSTALLED, RESOLVED, STARTING, ACTIVE, STOPPING). When you launch an RCP app, you are really booting Equinox and handing it the list of bundles to resolve. Equinox also wires up services registered through OSGi Declarative Services or the Service Registry, so plug-ins can find each other dynamically without hard imports.

From IDE to Standalone Product

The Eclipse IDE you download from eclipse.org is itself an RCP application with every optional plug-in installed. An RCP product is what you ship when you keep only the bundles you actually need, replace the IDE’s branding with your own splash and icons, and point the launcher at a custom config.ini. That separation is why the same Workbench code can power the IDE, a code review tool, or a domain-specific scientific dashboard.

How Plug-Ins and Extension Points Define the Application

Extension points are the reason RCP apps stay customizable. Each plug-in publishes a contract (the extension point schema) and any other plug-in can fulfill that contract by declaring an extension in its own plugin.xml. The platform reads those declarations at startup and stitches everything together without anyone calling a wiring function by hand.

Extension Points vs. Extensions

An extension point lives in a host bundle and acts like a published interface. An extension lives in a contributing bundle and provides an implementation. Common extension points include org.eclipse.ui.views for adding panels, org.eclipse.ui.editors for document tabs, and org.eclipse.ui.commands for reusable actions. You contribute an extension by adding an XML element under the matching extension-point id, and the platform instantiates your class when the user activates that view or fires that command.

The Inversion of Control Payoff

Adding a feature usually means dropping a plug-in into the dropins folder (or p2 repo) and restarting, not editing core code. That is inversion of control in the literal sense: the framework calls into your code at well-defined moments instead of your code calling into the framework. The practical consequence is that your core platform never needs to be forked, which keeps upgrades and security patches cheap.

That decoupling works in practice only because plug-ins advertise their capabilities through well-defined extension points.

“Think of extension points as power outlets on a wall. The host bundle installs the outlets and decides the voltage. Any other plug-in can walk up and plug in a lamp, a fan, or a toaster without rewiring the building.

The UI Stack: SWT, JFace, and the Workbench in Practice

The UI is split across three layers with very different responsibilities. SWT draws native widgets, JFace adds viewers and dialog frameworks, and the Workbench manages the window, perspectives, and parts. Knowing which layer owns what is what keeps you from reaching for the wrong tool.

SWT: Native Pixels at the Bottom

SWT is a thin Java wrapper around the host operating system’s widget toolkit. On Windows it calls into USER32, on macOS into Cocoa, on Linux into GTK. That is why an SWT Button looks like an OS button rather than a Java-drawn rectangle. The trade-off is platform-specific behavior leakage: a Tree behaves slightly differently on each OS, and you occasionally hit a widget that one platform lacks.

JFace: Viewers, Dialogs, and Content Providers

JFace sits on top of SWT and supplies the higher-level patterns that cut boilerplate. A TableViewer wraps an SWT Table and adds sorting, filtering, labels, and content providers that feed it domain objects. ResourceRegistry, FieldAssist, and PreferenceDialog handle icons, decoration support, and settings screens. When you find yourself writing a long SWT SelectionAdapter, the JFace layer almost always has a viewer class that does the same job in fewer lines.

The Workbench: Window, Perspectives, and Parts

The Workbench owns the top-level window, the perspective switcher, the editor area, and the trim (the bars around the edges). Parts come in two flavors: views read project state, and editors mutate documents through IEditorPart. The Workbench also drives the dirty/save lifecycle and propagates selection events across parts so a click in one view updates every view that listens.

Perspectives, Views, and Editors as User-Facing Building Blocks

Perspectives are saved arrangements of parts tuned to a specific task. The Java perspective in the IDE puts the Package Explorer on the left, the editor area in the middle, and the Outline and Problems views on the right. Switch to the Debug perspective and the same editor area is joined by the Debug stack and Breakpoints views. Each layout is configuration, not new code.

Views Read, Editors Mutate

Views extend ViewPart and display read-oriented state: project trees, search results, outline previews. Editors extend IEditorPart and are where documents live. The split matters because editors participate in dirty tracking, save lifecycle hooks, and multi-part selection propagation. When you select a node in a view, every view that implements ISelectionListener gets notified, which is how Outline and Properties views stay in sync with the active editor.

Configuring Layouts Without Code

Perspective layouts are stored as XML in plugin.xml under the org.eclipse.ui.perspectiveExtensions extension point. A product team can ship a default perspective plus a customizable one and let users rearrange parts through Window > Perspective > Customize. Because the layout is data, not code, redesigning the UI for a new role rarely means recompiling the application.

Once users can reshape layouts themselves, the harder question becomes how to ship those layouts to real machines.

Launching and Packaging an RCP Application

Packaging turns a pile of plug-ins into a launchable artifact. The Eclipse Product configuration is the heart of that step, and Tycho is the build tool that automates it for repeatable releases.

The.product File as the Source of Truth

A.product file declares the application’s ID, name, splash screen, about dialog, branding icons, and the IApplication class that Equinox starts. It also lists which plug-ins and features ship with the product. Treat the.product file as the contract between development and operations: anything not listed here is not in the binary.

Tycho and PDE Build

Tycho is a Maven plug-in (or a set of them) that resolves the dependencies declared in MANIFEST.MF and produces either a p2 repository or a single executable archive for your target OS. PDE Build does the same job from inside the IDE using Ant scripts. Tycho is the modern default because it ties RCP packaging into the same Maven lifecycle that handles CI and dependency proxies.

Standalone Binaries

The resulting executable does not require the Eclipse IDE to be installed on the target machine. You ship a folder with eclipse.exe (or the platform equivalent), a plugins/ directory, a configuration/ directory with config.ini, and your launcher. End users launch the binary and never see Equinox or OSGi, even though both are running underneath.

Trade-Offs and Common Pitfalls When Adopting RCP

RCP rewards modular thinking and punishes tight coupling. Knowing where the friction lives before you start saves a rewrite later.

Bundle Boundaries Need Discipline

Splitting a single class into two plug-ins because the directory layout looks tidy will cost you service-lookup boilerplate and ClassNotFoundExceptions at runtime. Draw bundle boundaries around things that change independently or ship separately. Internal helper classes belong inside the same bundle as their consumers; utilities that genuinely serve multiple plug-ins deserve a dedicated bundle with a clean export package.

SWT’s Native Feel Is Also a Constraint

SWT delivers platform fidelity, but a custom-drawn canvas still feels like a foreign object inside a native shell, and a few widgets differ across operating systems. Plan for platform testing early. If your UI must look identical on every OS, RCP is the wrong framework; pick JavaFX or a web stack instead.

The Workbench Assumes a Document-Centric Model

Perspectives, views, and editors fit naturally when the user opens documents and inspects them. Game-style canvases, full-screen data dashboards, or kiosk UIs will fight the Workbench model. In those cases, build on Equinox and SWT/JFace directly and skip the Workbench plug-ins entirely.

Scope the Platform Before Extending It

A focused subset of plug-ins almost always outperforms a fork of the full IDE. Pick the plug-ins your product actually needs (Mylyn, WTP, a custom reporting bundle), include only those bundles, and pin versions in the target platform. A smaller surface area means faster startup, fewer security patches, and a clearer upgrade path when the Eclipse Foundation ships a new release train.

Those trade-offs matter most when a team has to decide whether the platform earns its keep.

Bottom Line

A desktop application that grows by plug-in instead of by recompile is the clearest signal that RCP components earn their place in your stack. Start with Equinox and OSGi for isolation, add SWT/JFace for pixels, layer the Workbench on top only if your UI is document-centric, and package through Tycho for repeatable builds. Skip the framework when your UI is full-screen, custom-drawn, or must look identical across platforms, and reach for a different stack instead.

FAQ