Proposals

Eclipse Fastbelt is a toolkit for implementing domain-specific languages (DSLs) and other formal languages in Go. It is built for high performance on large workspaces and large files.

A DSL lets domain experts describe data, rules, or behavior in a concise text notation that software can check and process automatically. Users of such a language expect the same editor support as for programming languages: code completion, navigation, and immediate error feedback. This becomes hard to deliver when a workspace holds thousands of files or single files of several megabytes. Language tooling then tends to become slow and memory-hungry, and the responsiveness of editors starts to suffer dramatically.

Eclipse Fastbelt addresses this in its architecture: Language primitives such as tokens, AST nodes and cross-references are implemented using techniques that prevent costly memory allocations. Additionally, parsing, reference resolution, and validation run in parallel on multiple CPU cores, based on thread-safe data structures. Together, this ensures that Fastbelt is utilizing the available hardware as much as possible. In benchmarks, workspace builds are up to two orders of magnitude faster than with comparable frameworks.

The starting point of a Fastbelt project is a grammar definition, similar to Eclipse Xtext and Eclipse Langium. It describes the text syntax of the language together with the structure of the resulting abstract syntax tree (AST). From the grammar, Fastbelt generates Go code for the lexer, the parser, the AST types, and the resolution of cross-references between language elements, also across files. Language-specific behavior such as validation rules, scoping, interpreters, or code generators is added in plain Go code.

Fastbelt includes a language server based on the Language Server Protocol (LSP) with default implementations of code completion, go to definition, find references, hover, outline, workspace symbols, and folding. This makes a language available in Eclipse Theia, VS Code, and any other LSP-capable editor. The same language implementation can also be used as a library, e.g. in command-line tools and automation services.

Eclipse Fastbelt complements Eclipse Langium, which remains the first choice for most DSL projects and for web-based tools in the TypeScript ecosystem. Fastbelt is intended for cases where scale and performance are the central challenge.

Eclipse Wisteria Dataviz is a data visualization toolkit based on wxWidgets (https://github.com/wxWidgets/wxWidgets), with a focus on statistics and social sciences.
It ships in two forms:

- A stable C++ library that can be embedded into any wxWidgets application
- A stand-alone application (currently in alpha release) for building graphical reports interactively, with no coding required

Library features include:

- Numerous built-in graphs
- Interface for displaying tabular data
- Built-in printing, copying, and exporting support
- Data importing (Excel, OpenDocument Spreadsheet, CSV, tab-delimited, or user-defined delimited files) support
- Data transformations, such as filtering, pivoting (both longer or wider), subsetting, and recoding
- Data exporting (CSV, tab-delimited, or user-defined delimited files) support
- Image support, including the ability to use images for plot and bar backgrounds, logos, and point markers
- Image effects, such as oil-painting and Sepia tone
- Effects for boxes and bars, including transparency, a watercolor look, a glassy look, stipple brushes, and color fades
- Reference lines and areas
- Pre-defined and extensible color schemes
- Multi-plot support
 - Graphs can be embedded side-by-side on the same (scrollable) canvas
 - Includes support for setting a common axis for all graphs across a row or down a column

The CRaC (Coordinated Restore at Checkpoint) Project researches coordination of Java programs with mechanisms to checkpoint (make an image of, snapshot) a Java instance while it is executing. Restoring from the image could be a solution to some of the problems with the start-up and warm-up times.

Jakarta CRaC defines how to make the runtime aware of a checkpoint being taken and when it is being restored. It also defines a way for application developers to give instructions to the runtime how to handle external resources used by the application.

Goals

• Provide a standard mechanism to notify Jakarta EE implementations about checkpoint and restore events
• Provide a standard mechanism for Jakarta EE Applications to make implementations aware of resources to manage at checkpoint and restore events
• Work seamlessly with CRaC and InstantOn

Non-Goals

• The specification does not seek to replace the existing CRaC API (https://github.com/CRaC/org.crac)

Eclipse INCEpTION offers a browser-based platform for semantic text annotation. Text annotation is the task of adding structured information to documents: marking which spans mention a person, a disease or a gene, recording how those mentions relate to each other, and linking each one to a concept in a knowledge base. The annotated corpora that result are the raw material for linguistic and digital humanities research, for domain studies in fields such as medicine and law, and for training and evaluating machine learning models. Producing them is slow manual work, usually spread across several annotators whose output has to be reconciled into a single reliable gold standard.

Eclipse INCEpTION covers that entire workflow in one application. Users define their own annotation scheme in the browser, ground it in their own ontology, annotate alone or as a team, and let machine learning recommenders that train on the work done so far take over the repetitive part.

• Annotation against an ontology. Load RDF, OWL, OBO, SKOS or Turtle, or query a remote SPARQL endpoint live. Ready-made profiles for Wikidata, SNOMED CT, the Gene Ontology, the Human Phenotype Ontology and GND.
• Arbitrarily layered schemes. Entities, relations, coreference, syntax, frames and document labels over the same text, with typed features and slots, all configurable in the browser.
• Suggestions that improve while you work. Recommenders train on the annotations made so far; active learning surfaces the cases they are least certain about. Nothing is written to the corpus until the annotator accepts it.
• Quality control. Curate multiple annotators into a gold standard, measure inter-annotator agreement, and inspect the collected data in the Explorer.
• Flexible deployment. A desktop installer for a single researcher, or a server deployment for an entire institution, on self-hosted hardware and integrated with the organisation's single sign-on.
• Programmatic access. A REST API, webhooks, and support for user-supplied models through the external recommender interface.
• Interoperable formats. Imports plain text, PDF, HTML and TEI; exports UIMA CAS XMI/JSON with custom layers intact, or CoNLL-U.

Eclipse INCEpTION has since become a staple of the text annotation community — it was the most-used annotation tool reported at LREC 2026, and more than 120 papers published in 2025 and 2026 alone have used it (https://inception-project.github.io/papers-using-inception/).

Eclipse SysDaC modernizes the code journey from requirements to test, covering system architecture aspects like topology, interfaces, deployment, and communication.  The language is designed for creation and interpretation by AI agents, yet remains natural for humans to author and review.

Eclipse SysDaC provides a foundation for new workflows and collaboration models by:

• Centralizing the system description in a single model
• Enabling code-like collaboration with Git workflows
• Supporting agentic development loops

It also serves as input for automated derivation of downstream artifacts for µC- and µP-based nodes and subsystems.

In contrast to existing approaches, the project is built on two core principles: an open-source foundation and a consistent configuration-as-code methodology. It is explicitly designed for cross-industry use, covering automotive, commercial vehicles, medtech, agriculture, industrial automation, avionics, and defense.

The project consists of the following building blocks:

1. Schema (meta-model) and text-based syntax for SysDaC files
2. Tooling for creating and validating of SysDaC files
3. Documentation and examples

The initial contribution will be sponsored by Technica Engineering GmbH (Member of KPIT Group) and Vector Informatik GmbH, which will each fund a first group of committers. The project is nevertheless intended to be governed as an open, vendor-neutral community from the outset, and contributions from OEMs, Tier-1 suppliers, tool vendors, and adopters in other industries are actively invited.

Eclipse SCINTX (Supply Chain Intelligence Exchange) is a vendor-neutral open standard and reference implementation for package-security integration. It sits between package registries / CI systems and security providers. Users submit package artifacts (e.g. by PURL and digests). The gateway assesses them via pluggable providers, evaluates consumer policy, and returns portable decisions and findings. Outcomes can be delivered by polling or signed CloudEvents webhooks; consumers may adjudicate review decisions and share the final allow/deny gate back to the gateway.

The goal is to eliminate duplicated registry–vendor integrations, make security verdicts comparable and portable, and let registries and enterprises mix-and-match conforming providers without lock-in.

Eclipse S-CORE Verified is the verification project for Eclipse S-CORE.

It takes a candidate distribution that claims to be based on Eclipse S-CORE and exercises it against an open, versioned suite of tests that reflect the upstream S-CORE codebase: API behaviour, runtime characteristics, integration contracts between S-CORE components, and the documented external interfaces of the platform.

The goal is to verify that a distribution not only leverages Eclipse S-CORE version X, but also adheres to its expected behaviour and established quality standards, using reproducible technical evidence rather than relying on marketing claims alone.

By running and passing a prescribed and versioned set of tests from the Eclipse S-CORE Verified suite, a distribution can demonstrate that:

• Its public APIs and interfaces correspond to the upstream Eclipse S-CORE baseline at a stated version.
• Its runtime behaviour for the components covered by the suite is consistent with the upstream reference implementation.
• The traceable identity between the upstream Eclipse S-CORE release and the components shipped in the distribution can be established and audited.

In addition to verifying that distributions are release-ready against the upstream baseline, the Eclipse S-CORE Verified tests may also serve to verify the quality of new functionality during S-CORE upstream development itself, providing a continuous quality signal back to the Eclipse S-CORE project.

The project will be operated as an open, community-driven asset under Eclipse Foundation governance, with public repositories, public meeting notes, and open contributor processes — consistent with Eclipse S-CORE's "Open by Choice. Safe by Design." principle.

Architecture

Eclipse LIBERSOM follows a modular, layered architecture with clear separation of concerns. The entire stack compiles into a single library (opensomeip) with no external runtime dependencies beyond a C++17 standard library and platform threading/sockets.

Layers:

- Core: Message structures, session management, error handling, return codes
- Serialization: SOME/IP data type serialization/deserialization with big-endian byte order
- Transport: UDP (configurable blocking/non-blocking, buffer sizes) and TCP (connection management, framing) bindings
- Service Discovery: SOME/IP-SD multicast-based offer/find/subscribe with IPv4 options
- Transport Protocol: Large message segmentation and reassembly over UDP (SOME/IP-TP)
- RPC: Request/response client and server for method calls
- Events: Publish/subscribe communication with event groups
- E2E Protection: CRC-based message integrity with profile registry and standard profile
- Platform Abstraction (PAL): Portable threading, sockets, memory allocation, and byte-order APIs

Platform Support:

- POSIX (Linux, macOS) — Stable, primary development and CI target
- Windows (Winsock) — Supported, Win32 socket backend
- Zephyr RTOS — Stable, module system, native_sim + NXP S32K388 Renode simulation
- FreeRTOS + lwIP — Stable, Linux POSIX port + Renode STM32F407 Cortex-M4F simulation
- Eclipse ThreadX + lwIP — Stable, Linux port + Renode STM32F407 Cortex-M4 simulation
- Static allocation (no-heap) — Supported, optional ETL-based containers for lockstep/safety-critical targets

Current Maturity (v0.1.0):

- Total specification requirements: 669
- Fully traced (code + tests): 594 (88.8%)
- C++ unit test cases: 443 across 15 suites
- Python integration/conformance tests: 80+
- CI workflows: 16 (host, RTOS, Zephyr, static analysis, requirements, RPM, etc.)
- Total commits: 500+
- Active development since: 2025

Quality and Engineering Practices:

- Requirements traceability: Automated tooling maps specification requirements to @implements and @tests annotations in source code
- Continuous integration: 16 GitHub Actions workflows covering host builds, FreeRTOS, ThreadX, Zephyr, Python tests, clang-tidy, Coverity Scan, requirements validation, and RPM packaging
- Hardware simulation: Renode-based CI testing on ARM Cortex-M4 targets (STM32F407, NXP S32K388)
- Static analysis: clang-tidy, Coverity Scan, AddressSanitizer, UndefinedBehaviorSanitizer
- Documentation: PlantUML architecture diagrams, Sphinx-Needs requirements, API docs, porting guides
- Packaging: CMake presets for all targets, RPM spec via Packit/Copr, Docker test environments

Open SOME/IP Specification

OpenSOME/IP is developed against the Open SOME/IP Specification — a community-driven specification project (included as a git submodule) that defines normative requirements for interoperable SOME/IP communication. The specification operates under the SOME/IP Community Specification License 1.0 and provides a vendor-neutral reference for conformance.

Ecosystem Integration

The project is designed for composition with other Eclipse SDV technologies:

- Eclipse ThreadX — Direct RTOS backend (PAL implementation)
- Eclipse Zenoh — Gateway bridge (planned, separate repo)
- Eclipse Cyclone DDS — Gateway bridge (planned, separate repo)
- Eclipse uProtocol — Gateway bridge (planned, separate repo)
- Eclipse Velocitas — Vehicle service communication layer

Eclipse Coffee Builder for Jakarta EE is an open source tool that helps developers create and evolve Jakarta EE applications progressively.

Eclipse Coffee Builder creates a small and understandable Jakarta EE project foundation that developers can extend by adding capabilities as their application evolves. Each capability can introduce the dependencies, Maven configuration, and supporting project structure required for the selected Jakarta EE technologies.

The central idea of Eclipse Coffee Builder is:

"Eclipse Coffee Builder generates the foundation. The developer builds the application."

This approach keeps the generated project transparent and allows developers to understand how Jakarta EE technologies are introduced into the application, including their dependencies, build configuration, and project structure.

Eclipse Coffee Builder is intended to serve primarily as a practical development tool while also supporting developers who want to better understand how Jakarta EE applications are assembled. By making the evolution of the generated project explicit, Eclipse Coffee Builder encourages developers to remain in control of the resulting application rather than treating generated code and configuration as a black box.

Eclipse AAS Core Works provides reusable core libraries and tooling for working with Asset Administration Shells (AAS), the standardized Digital Twin concept used in Industry 4.0.

The project formalizes published AAS meta-models in machine-readable form and uses these representations to generate consistent SDKs, schemas, serialization logic, verification logic, package handling libraries, test data, and utility tools across multiple programming languages.

The goal is to make it easier for tool builders, application developers, researchers, and other Eclipse Digital Twin projects to create, validate, serialize, deserialize, inspect, package, and exchange AAS data with a high degree of correctness and consistency.