S-Core v0.5-alpha release notes#

S-Core v0.5-alpha release note
status: valid
security: YES
safety: ASIL_B
realizes: wp__platform_sw_release_note
doc__score_v05_alpha_release_note
Generic Document
Platform Name: S-CORE
Release Tag: v0.5.0-alpha
Origin Release Tag: none - first published release
Release Date: 2025-11-17

Overview#

This is the first published release of the Eclipse S-CORE platform (v0.5.0-alpha). It brings together the initial set of core modules, reference integrations, and supporting infrastructure needed to build and run example applications such as the scrample demo on multiple target images. The software architecture and implemented modules are illustrated in the diagram below.

This release of Eclipse S-CORE is an early alpha version intended solely for experimentation, test driving project processes, gaining experience in release creation and soliciting feedback. Please be aware, that features may be incomplete, the software may exhibit instability or unexpected behavior, and breaking changes and alterations in scope are likely as development progresses.

Architecture overview

Highlights#

  • First public alpha of the Eclipse S-CORE platform.

  • Reference integration including the scrample demo application.

  • Initial set of communication, persistency, orchestration, and base utility modules.

  • Experimental reference images for QNX, Red Hat AutoSD Linux, and EB corbos Linux for Safety Applications.

Eclipse S-CORE book#

The first version of the Eclipse S-CORE book is a “how-to” guide for users getting started with the project. It introduces the core concepts of Eclipse S-CORE and walks through building the scrample application step by step on top of the platform modules.

Improvements#

This release introduces the initial integrated platform with the modules listed below. For module-specific improvements, refer to the release notes in each module repository.

Bug Fixes#

Bug fixes are tracked and documented per module. Please see the corresponding module release notes for details on fixed issues in this release.

Integrated Software Modules#

Communication#

Zero-copy, shared-memory based inter-process communication for minimal-latency intra-ECU messaging.

Fixed Execution Order Framework(FEO)#

Application Framework which is intended to support data-driven or time-driven applications.

  • Link to release: feo v1.0.2

  • Source / tag: FEO GitHub release

  • Release notes:

    • A framework for applications (not for platform services)

    • For data-driven and time-driven applications (mainly in the ADAS domain)

    • Support fixed execution order

    • Supporting reprocessing

    • Read more on scope.

    • Check out the examples.

Baselibs#

Selection of basic C++ utility libraries for common use in the S-CORE project

Persistency#

Ensures long-term storage and retrieval of data and provides a reliable mechanism for preserving application state and data integrity over time.

Orchestrator (Kyron and orchestration framework)#

Provides:

  • Kyron – an async runtime for Rust, designed for high-performance async/await execution with functional safety in mind. It offers fine-grained control over scheduling, thread management, and workload isolation via configurable execution engines.

  • Orchestrator – a framework to build task chains with deterministic execution flow. It lets developers describe cause–effect chains, timing constraints, and error handling in a platform-independent way while keeping application logic separate from deployment and resource management.

  • Version: orchestrator v0.0.3

  • Source / tag: Orchestrator GitHub release

  • Further reading:

Reference integration#

Central integration of Eclipse S-CORE modules

Common#

  • Integrates all v0.5 modules, including the scrample demo application.

  • Provides CI/CD workflows to ensure stability of the reference integration:

Reference QNX image#
Reference Red Hat AutoSD Linux image (Experimental)#

  • Provides a Linux-based AutoSD image usable with QEMU for both x86_64 and aarch64; for usage see AutoSD README

  • Integrates IPC tests (equivalent functionality to the scrample example) using the QM environment.

  • A dedicated build_and_test_autosd execute these tests.

  • Note: The AutoSD Linux integration is experimental and does not yet follow the full S-CORE process. Bazel integration is still missing and will be addressed in upcoming releases.

Reference Elektrobit corbos Linux for Safety Applications Linux image (Experimental)#

  • Demonstrates Eclipse S-CORE running on Elektrobit corbos Linux for Safety Applications (EBcLfSA).

  • Integrates the scrample demo application into the “fast-dev” EBcLfSA image (aarch64).

  • In the related CI workflow, all these steps are performed, and the resulting log files are stored and made available for download.

  • Integration can be executed via QEMU; see the EBcLfSA README for details.

  • Note: The EBcLfSA integration is experimental. Bazel integration exists, but parts of the integration code will be reworked in future releases.

Associated Infrastructure Modules#

process_description#

Provides a process model establishing organisational rules for developing open source software in the automotive domain, suitable for safety and security contexts.

docs-as-code#

Tooling for linking and generation of documentation.

tooling#

Tooling for S-CORE development.

ITF (Integration Testing Framework)#

Framework for executing feature integration tests on the reference image.

Test Scenarios#

Testing framework providing a backend for parametrizable scenarios in Rust and C++, usable in common test case implementations and parallel implementations.

  • Version: test_scenarios v0.3.0

  • Source / tag: Test Scenarios

  • Components: - test_scenarios_cpp – C++ framework for defining, running, and managing test scenarios. - test_scenarios_rust– equivalent implementation in Rust.

  • Both frameworks share the same concepts and support automated testing, scenario grouping, and integration with CLI tools.

Performed Verification#

The following tests were executed as part of this release:

  • All C++ modules built successfully with GCC and QCC toolchains.

  • All Rust modules built successfully with the Rust toolchain.

  • Each module executed its unit tests.

  • Basic integration tests were executed on the reference QNX image in QEMU via the release verification workflow

  • for persistency and orchestration modules, component and feature integration tests were executed using the score-test-scenarios framework; see feature_showcase and feature_integration_tests for more details.

Known Issues#

  • see release notes of every module seperately

Upgrade Instructions#

  • none, first published release.

Contact Information#

For any questions or support, please contact the Project lead or raise an issue/discussion.