Platform architecture

The Eclipse platform is structured around the concept of plug-ins. Plug-ins are structured bundles of code and/or data that contribute function to the system. Function can be contributed in the form of code libraries (Java classes with public API), platform extensions, or even documentation. Plug-ins can define extension points, well-defined places where other plug-ins can add functionality.

Each subsystem in the platform is itself structured as a set of plug-ins that implement some key function. Some plug-ins add visible features to the platform using the extension model. Others supply class libraries that can be used to implement system extensions.

The Eclipse SDK includes the basic platform plus two major tools that are useful for plug-in development. The Java development tools (JDT) implement a full featured Java development environment. The Plug-in Developer Environment (PDE) adds specialized tools that streamline the development of plug-ins and extensions.

These tools not only serve a useful purpose, but also provide a great example of how new tools can be added to the platform by building plug-ins that extend the system.

line drawing of the architecture of the sdk

Platform SDK roadmap

Runtime core

The platform runtime core implements the runtime engine that starts the platform base and dynamically discovers and runs plug-ins. A plug-in is a structured component that describes itself to the system using an OSGi manifest (MANIFEST.MF) file and a plug-in manifest (plugin.xml) file. The platform maintains a registry of installed plug-ins and the function they provide.

A general goal of the runtime is that the end user should not pay a memory or performance penalty for plug-ins that are installed, but not used. A plug-in can be installed and added to the registry, but the plug-in will not be activated unless a function provided by the plug-in has been requested according to the user's activity.

The platform runtime is implemented using the OSGi services model. While implementation details of the runtime may not be important to many application developers, those already familiar with OSGi will recognize that an Eclipse plug-in is, in effect, an OSGi bundle.

The best way to get a feel for the runtime system is to build a plug-in. See Plug it in: Hello World meets the workbench to get started building a plug-in. To understand the nuts and bolts of the runtime system, see Runtime overview.

Resource management

The resource management plug-in defines a common resource model for managing the artifacts of tool plug-ins. Plug-ins can create and modify projects, folders, and files for organizing and storing development artifacts on disk.

Resources overview provides an overview of the resource management system.

Workbench UI

The workbench UI plug-in implements the workbench UI and defines a number of extension points that allow other plug-ins to contribute menu and toolbar actions, drag and drop operations, dialogs, wizards, and custom views and editors.

Plugging into the workbench introduces the workbench UI extension points and API.

Additional UI plug-ins define frameworks that are generally useful for user interface development. These frameworks were used to develop the workbench itself. Using the frameworks not only eases the development of a plug-in's user interface, but ensures that plug-ins have a common look and feel and a consistent level of workbench integration.

The Standard Widget Toolkit (SWT) is a low-level, operating system independent toolkit that supports platform integration and portable API. It is described in Standard Widget Toolkit.

The JFace UI framework provides higher-level application constructs for supporting dialogs, wizards, actions, user preferences, and widget management. The functionality in JFace is described in Dialogs and wizards and JFace: UI framework for plug-ins.

Team support

The Team plug-ins allow other plug-ins to define and register implementations for team programming, repository access, and versioning. The Eclipse SDK includes a CVS plug-in that uses the team support to provide CVS client support in the SDK.

Team support is described in Team support.

Debug support

The Debug plug-ins allow other plug-ins to implement language specific program launchers and debuggers.

Debug support is described in Program debug and launching support.

Help System

The Help plug-in implements a platform optimized help web server and document integration facility. It defines extension points that plug-ins can use to contribute help or other plug-in documentation as browsable books. The documentation web server includes special facilities to allow plug-ins to reference files by using logical, plug-in based URLs instead of file system URLs.

Additional features are provided for integrating help topics in product level documentation configurations.

The help facility is described in Plugging in help.

Java development tools (JDT)

The Java development tools (JDT) plug-ins extend the platform workbench by providing specialized features for editing, viewing, compiling, debugging, and running Java code.

The JDT is installed as a set of plug-ins that are included in the SDK. The Java Development User Guide describes how to use the Java tools. The JDT Plug-in Developer Guide describes the structure and API of the JDT.