Skip to content

About

Eclipse Platform - a comprehensive set of frameworks and common services that collectively provide a powerful software development infrastructure.

Resources

Contributing

Security policy

Stars

0 stars

Watchers

0 watching

Forks

 
 

Repository files navigation

Eclipse Platform: workspace and runtime foundations

Eclipse Platform supplies the services behind Eclipse-based applications: workspace files and projects, background jobs, launch/debug infrastructure, team integration, terminals and help. Use this repository to understand or change those services. For native widgets use SWT; for viewers, editors and workbench presentation use Platform UI; for assembling the full SDK use the releng aggregator.

Source map · Concepts · Quickstart · Worked example · Detailed reference

Platform source map

Question Implementation owner What to inspect
How are projects/files represented? resources/ Workspace resources, filesystem adapters and resource tests
How is background work coordinated? runtime/ Jobs, scheduling rules, runtime services and their tests
How are programs launched/debugged? debug/ Launch configuration, breakpoints and debug model
How do compare/merge and synchronization work? team/ Team providers, diffs, synchronization and merge integration
Where are terminal/help integrations? terminal/ and ua/ Connectors, help, cheatsheets and their owning bundles

The root reactor defines the build modules. A directory is not automatically a standalone application or an exported API.

Platform key concepts

  • Workspace / resource: Eclipse's model of projects, folders and files; its notifications and refresh rules are distinct from arbitrary filesystem I/O.
  • Job: schedulable background work. Cancellation is cooperative, and a sampled job state can change immediately after it is read.
  • Scheduling rule: declares conflicting work; it is part of concurrency correctness, not simply a priority or a performance hint.
  • Bundle / extension: an OSGi deployment unit and an Eclipse contribution mechanism. Check the manifest and extension declarations before changing an API.
  • Tycho / target platform: Maven tooling and the resolved Eclipse dependency set used to build bundles and run their test harnesses.

Platform fork status

This is the downstream hsoliwal fork of Eclipse Platform. The checkout contains the established Platform implementations, an isolated M3 recipe/inventory sidecar, and a source-reference coverage ledger. The sidecar's inventory/build lanes and the M3 research direction below do not establish that runtime integration or performance improvements are qualified. The reference explicitly separates structural inventory from complete API semantics.

Platform quickstart

For the inspected revision, Jenkins selects JDK 25. Prepare Maven, network access to Eclipse parent/p2 repositories and a display for UI-dependent tests. The existing Oomph instructions below provision an upstream workspace; confirm the remote and branch when working on this fork.

git clone https://github.com/hsoliwal/eclipse.platform.git
cd eclipse.platform
git rev-parse HEAD
java -version
mvn -version
mvn clean verify

These are source-checked entry points, not a recorded successful build. Read the Maven defaults and POM if parent resolution fails; the individual-bundle profile supports remote parent resolution.

Platform cheat sheet

# Locate scheduling contracts and their tests without running a build.
git grep -n -e 'ISchedulingRule' -e 'isCanceled' -- runtime
# Locate resource notification entry points.
git grep -n 'IResourceChangeListener' -- resources
# Inspect the ordinary build/test reports after a run.
find . -path '*/target/surefire-reports/TEST-*.xml' -print

An API baseline failure belongs with target/apianalysis; a native/display failure belongs with the harness environment. Jenkins allows test failures to be collected, so a zero Maven exit code alone is not a passing-test receipt.

Platform worked example

Trace a cancellation before changing the scheduler. Open Job.java and ISchedulingRule.java.

  1. Follow schedule() into the managed lifecycle rather than calling a job's implementation as an ordinary method.
  2. Read cancel(): a running job may not stop immediately. Its work must observe cancellation through the progress monitor and finish appropriately.
  3. Treat getState() as a recent observation, not a lock or completion guarantee.
  4. Before adding shared-resource work, check the scheduling rule's conflict and containment contracts. A faster run that violates them is not equivalent.
  5. Reproduce completion, cancellation and conflicting jobs in the owning runtime tests; record command, test counts and reports. This tour itself ran no tests.

Continue with API guidance, coding conventions and the pinned source reference. The original project introduction, contribution instructions and license follow.

Source tour checked at 6d3bbf2ae2c3. Commands describe that revision; recheck build configuration when changing revisions. Build/UI/performance verification was not run for this README update.


M³ × Eclipse Platform

Workspace resources, jobs and team workflows make excellent correctness-first workloads.

M3 research target Evidence first

M3 runtime programme · Technical paper · Source invitation

Note

This is an experimental downstream fork of the upstream Eclipse Platform 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.

Engineering questions for this fork

Surface What to investigate Non-negotiable contract
Workspace resources Compare repeated scans, metadata reuse and lookup plans IResource semantics, refresh behavior and change notifications
Jobs and scheduling Measure contention and reused computation ISchedulingRule correctness and cancellation
Team/merge Use reproducible patch and compare/merge workloads No loss of content, history or diff/merge semantics

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.

Come inspect the code

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 documentation. Nothing in this introduction rebrands upstream work as M3-authored code.


M3 direction in this fork

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 fork is a target for exploring how qualified runtime and collection changes affect workspace, resource, scheduling, and platform workloads.

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.


Eclipse Platform Project

Thanks for your interest in this project.

Project Description

This repository contains the basis for the Eclipse IDE and a sub-repository of the eclipse-platform organization. It contains multiple modules:

Platform provides images like the splash screen.

Resources provides Java interfaces like IResource and implementations of workspace, folder, file and file system abstraction.

Runtime provides Java interfaces like IJob, ISchedulingRule and implements scheduling of multithreaded jobs with exclusive access to a resource.

Update provides Java interfaces like IPlatformConfiguration. IPlatformConfiguration represents the runtime configuration.

Debug provides Java interfaces such as ILaunchConfiguration, IDebugTarget, and IBreakpoint to implement a language-agnostic framework for launching programs, managing breakpoints, and inspecting runtime state.

Team provides Java interfaces such as IResourceDiff and IDiff to implement a framework for version control integration, resource synchronization, and two-way and three-way comparison that support merging of files and resources.

Terminal provides Java interfaces such as ITerminalConnector and ITerminalViewControl to implement an embeddable terminal widget with support for local, SSH, and Telnet connections.

Working with this checkout

Choose the right repository

This checkout contains core Platform services and integrations. SWT widgets and native libraries live in the separate SWT repository; JFace, editors and the workbench live in Platform UI. For an assembled Eclipse SDK, use the SDK aggregator and its recorded submodule revisions.

In addition to the modules above, ant/ contains Ant integration and ua/ contains user assistance. The root POM is the build's module inventory. Start with the affected component's bundles and tests rather than treating every directory as an independent Java application.

Build and test

Use the Oomph setup below for an Eclipse/PDE workspace. It provisions the upstream Platform development environment; check which Git remote and branch you are editing when working on this fork.

For a command-line build, run from the repository root:

mvn clean verify

The checked-in Jenkinsfile selects JDK 25. Use it as the reference JDK for reproducing this revision's CI, rather than assuming older Java requirements in historical notes still describe the build. .mvn/maven.config enables build-individual-bundles; the POM uses that profile to resolve the Eclipse Platform parent from repo.eclipse.org when it is not available in a sibling aggregator checkout. Parent/target resolution therefore requires access to the configured Eclipse repositories.

Some tests need a graphical display. Jenkins wraps the build in Xvnc; a command-line build is not necessarily display-free. The Jenkins lane also enables bree-libs, api-check and javadoc. Consult its full command when reproducing those checks, including the corresponding toolchain setup.

Read **/target/surefire-reports/TEST-*.xml for test results, **/target/apianalysis/*.xml for API analysis, and **/target/compilelogs/*.xml for compiler diagnostics. Jenkins uses maven.test.failure.ignore=true, so the Maven exit status alone does not establish that tests passed.

Before opening a contribution

How to Contribute

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.

Create Eclipse Development Environment for Eclipse Platform

Documentation

For additional documentation, please refer to the docs directory and The Official Eclipse FAQs.

Issue Tracking

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 repository, you can find existing issues or create new issues within this repository.

Contact

Contact the project developers via the project's "dev" list.

License

Eclipse Public License (EPL) 2.0

Pinned project, module and package reference

The source reference maps every metadata-backed project/module path and recognized Java namespace at the documented revision. It includes selected build/API/lifecycle contracts and an explicit coverage ledger. Structural accounting is not a claim of complete package semantics, successful builds or verified M3 integration.

About

Eclipse Platform - a comprehensive set of frameworks and common services that collectively provide a powerful software development infrastructure.

Resources

Contributing

Security policy

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages