Proposals

Eclipse AASPortal is written in TypeScript and based on a distributed software architecture, that  includes a Node.js based “aas-node” and an Angular based web application “aas-portal” (using Bootstrap 5 and NgRx). Via the standardized AAS REST API, Eclipse AASPortal connects to AAS endpoints, e.g. based on Eclipse AASX Package Explorer and Server, Eclipse BaSyx, or Eclipse FA³ST. These endpoints can be configured during operation by authorized users. Additionally, operational data can be integrated via OPC UA (based on node-opcua) and visualized in corresponding plots. AASPortal enables full text search and filtering of AAS, as well as basic modelling capabilities like adding Submodel templates or editing  values of properties.

The Cyber Resilience Practices Project develops specifications designed to help improve the cyber resilience of open source projects and of the products that incorporate these projects and facilitate compliance with related regulation worldwide.

The Eclipse LMOS project (Language Model Operating System) is essentially a platform for building and running AI systems that can handle complex tasks. Imagine it like an operating system for your computer, but instead of managing applications, it manages AI agents. These agents are like smaller, specialized AI programs that each handle a specific part of a larger problem.

The key idea behind Eclipse LMOS is to break down complex tasks into smaller parts that can be handled by different AI agents. For instance, if you're building a customer service chatbot, one agent might handle basic greetings, another might answer questions about billing, and another might deal with technical support issues. This way, each agent can be really good at its specific job, leading to better overall performance.

Eclipse LMOS helps these agents work together by providing a common platform where they can communicate and share information. It's like a central hub that keeps everything organized and running smoothly. This platform also makes it easier to manage and scale the system as needed. If you need to add more agents or handle more traffic, LMOS can handle it without breaking a sweat.

Eclipse LMOS was designed to be very flexible and user-friendly. You don't need to be an AI expert to use it. The platform provides tools and features that make it easy to build, deploy, and manage AI agents.

We see Eclipse Fennec as incubator and space for any EMF and OSGi related projects. Over the years we have massively used these two technologies in our projects. 

We put some extensions to EMF to make it work in an optimal OSGi manner. Based on that we build additional components for existing OSGi specifications like the Whiteboard for Jakarta Restful Web Services that are able to serialize and de-serialze EMF Instances. 

We build a lot of other frameworks on top of that, like a Serializer / De-Serializer frameowrk to be capabile to save load EMF with the same configuration in different formats like MongoDB, JPA, Lucene, Json / Yaml.

We needed all this components to use EMF end-to-end in an application.

• EMF OSGi - EMF Framework as OSGi Service, Code Generator for these components

• EMF-Util - Extensions based on EMF OSGi to customizer serialzing, Jakarta RS extension to work with EMF

• Model-Atlas - Distributed EMF Model Registry

• EMF- Codec - Serializer, De-serializer framework for EMF in an OSGi based way

• EMF Persistence - Persistence extension for EMF in an OSGi environment

• Mapping Layer (‘QVT Transformation in an OSGi way)

• Privacy layer - Framework to analyze model and/or model instances for privacy related information

The Eclipse Safe Open Vehicle Core project aims to develop an open-source core stack for Software Defined Vehicles (SDVs), specifically targeting embedded high-performance Electronic Control Units (ECUs).

As these ECUs carry multiple processors, the project also targets for interoperability between these processors.

To ensure applicability in the automotive domain we ensure compliance with relevant safety standards, such as ISO 26262 for functional safety, providing a reliable foundation for safety-critical applications and adherence to stringent security standards, implementing robust cybersecurity measures in accordance with ISO/SAE 21434 and UNECE WP.29.

A key aspect of the project is the design of a modular and extensible architecture, allowing easy integration and customization for various automotive applications, ensuring flexibility and scalability. Additionally, the project focuses on end-to-end optimization throughout the stack to achieve maximum efficiency and performance.

The project is guided by several key principles:

Common Stack & Industry-Wide Collaboration

The Safe Open Vehicle Core project aims to create a common full stack solution of a software runtime that serves as the best possible solution for shared industry problems. By achieving efficiencies through a single, joint solution instead of multiple specific ones, the project addresses non-differentiating scopes and ensures that the scope is significant for multiple parties, rather than catering to singular interests.

Speed

The project accelerates development by working in open source, focusing on code-centric and iterative methods rather than primarily on textual specifications.

Abstraction and Extensibility

The project emphasizes the decoupling of hardware (HW) and software (SW), ensuring that applications do not depend on specific hardware characteristics. It establishes predetermined breaking points to enable the exchange of implementations of individual layers, aspects, and components, such as ECU communication protocols. Additionally, it focuses on enabling project-specific extensions of the stack, providing a flexible framework that can be customized and extended to meet the specific requirements of different projects.

Quality & Efficiency

The Safe Open Vehicle Core project aims for a lean, no-frills solution to lower complexity and increase efficiency. The project strives for support of modern implementation paradigms and languages like Rust or C++, uses human-readable specification languages that are domain and target-driven, and avoids complex exchange data formats. It seeks the optimal balance between modularity and resource consumption and follows state-of-the-art processes to develop safe and secure software in an open-source environment.

By achieving these goals and adhering to these key principles, the [SafeOpenVehicleCore] Project aims to deliver a versatile and secure core stack that supports the evolving needs of the automotive industry and accelerates the adoption of software-defined vehicle technologies.

Eclipse Cuneiform offers support for analyzing C/C++, Java, and C# source code to identify internationalization (i18n) issues. Additionally, Eclipse Cuneiform assists in reviewing and pseudo-translating translation catalogs, including gettext (.po files), Java .properties files, XLIFF files, and .NET formats like .resx and .xaml. We also provide support for reviewing Windows resource files (.rc).

Eclipse Open Collaboration Tools is a set of libraries, extensions and tools for integrating collaborative editing with multiple editing paradigms (textual, graphical, etc.) and in multiple IDEs or other applications.

The basic idea is simple: one person starts a collaboration session as host and invites others to join. The IDE extension distributes the contents of the hostʼs workspace and highlights text selections and cursor positions of other participants. In parallel, they get together in their favorite meeting or chat app for immediate discussion. All participants see what the others are looking at and what changes they propose in real-time. This way of remote collaboration reduces confusion and maximizes productivity.

The project includes the following components:

• A protocol definition based on JSON messages, with a reference implementation in TypeScript
• A Node.js based server for handling authentication and forwarding messages between participants of a collaboration session
• A VS Code extension for collaborative text editing
• Additional integrations: Eclipse IDE, Monaco Editor, and more to come

An integration with Eclipse Theia is already included in the Theia project.

Eclipse SKyBT (Smart Keyword Based Testing)

The core idea of Eclipse SKyBT: Based on our experience from numerous projects, the success factor of testing lies in the test design, everything else can and should be automated as much as possible.

With Eclipse SKyBT the test designers are able to describe the system under test as a model by using a defined syntax and keywords. The model includes the definition and selection of the needed interfaces, logical relations as a state machine and description of the logical objects with keyword sentences.

Custom keywords can be defined as needed for the current project. Platform or communication definitions can be imported and then be used as keywords. The keyword and syntax management are embedded.

Form these keyword-based models of the system under test the test designer is able to generate the needed testcase using the testcase generator. 

Of course, the user is also able to write classic testcases based on the syntax and keywords.

The models and testcases can be combined with parameters and test data sets.

As most of the test departments already have a working test management, testcases can be exported to the used application lifecycle management tools. 

Coming from the ALM tool the configured test suites can be executed in the used test automation. Since the testcases are based on keywords, there is no need to implement or update the testcase. All testcases that are based on the already implemented keywords can be executed directly. 

Both Log4j and SLF4J contain legacy elements that are outdated by modern standards. This project aims to distill the most effective features from both APIs. A new Jakarta Logging API will be modern, user-friendly, and efficient. The goal is to make upgrading to the Jakarta Logging API straightforward, ensuring that it feels familiar to current users while providing improved functionality and simplicity.

Eclipse XSM (eXtensible State Machine) provides a middleware to implement state machines. It allows to alter an existing state machine without altering the existing code. As a middleware it does not provide a  service to a user directly but helps developers to focus on business logic.

An example:

Imagine a simple LIN node. The standard behavior might be, that if it cannot serve due to internal issues it signals no service to its master. A carmaker explicitly requires the LIN node to signal operating the first 2s after powering on. With Eclipse XSM you can add this custom behavior without touching the existing code.