The automotive industry’s transition to service-oriented architectures over Ethernet relies heavily on the SOME/IP (Scalable service-Oriented MiddlewarE over IP) protocol. SOME/IP is the de-facto standard for in-vehicle service communication in AUTOSAR Classic and Adaptive platforms, enabling ECU-to-ECU method calls, event notifications, and service discovery over IP networks.
Despite its critical role, the open-source ecosystem for SOME/IP is limited. Existing implementations are either tightly coupled to specific AUTOSAR stacks, carry restrictive licenses, or lack support for the real-time operating systems that dominate automotive ECUs. This gap forces OEMs and Tier-1 suppliers into vendor lock-in or costly in-house development, slowing innovation and interoperability testing.
The Eclipse SDV Working Group already hosts projects addressing vehicle abstraction (Eclipse Velocitas), communication middleware (Eclipse uProtocol, Eclipse Zenoh), and operating systems (Eclipse ThreadX). However, no project provides a standalone, multi-platform SOME/IP protocol stack — the fundamental building block that connects these higher-level frameworks to the Ethernet-based vehicle network.
Eclipse LIBERSOM fills this gap with a production-oriented, Apache 2.0-licensed C++17 implementation that runs on Linux, Zephyr RTOS, FreeRTOS, and Eclipse ThreadX, complementing the existing SDV portfolio.
Eclipse LIBERSOM provides a complete, open-source C++17 implementation of the SOME/IP
protocol stack for automotive and embedded systems. The project delivers:
• A modular, layered library implementing SOME/IP message handling, serialization, service
discovery, transport protocol, RPC, events, and end-to-end protection
• A platform abstraction layer enabling deployment on POSIX hosts, Zephyr RTOS, FreeRTOS,
and Eclipse ThreadX
• Comprehensive requirements traceability against the Open SOME/IP Specification
• Production-quality test suites, CI/CD pipelines, and documentation
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
None known. The implementation is clean-room from publicly available standards:
- SOME/IP protocol behavior from the Open SOME/IP Specification
- CRC algorithms from SAE J1850 and ITU-T X.25 (public standards)
- No code derived from proprietary AUTOSAR specifications
All dependencies are permissively licensed: Google Test (BSD-3-Clause), FreeRTOS (MIT), Eclipse ThreadX (MIT), lwIP (BSD-3-Clause), ETL (MIT).
The Eclipse Foundation is the natural home for LIBERSOM because:
1. Fills a critical gap: Eclipse SDV has projects for vehicle abstraction, service meshes, and operating systems, but no standalone SOME/IP stack — the protocol that physically connects ECUs on automotive Ethernet.
2. Already uses Eclipse technology: The project directly integrates Eclipse ThreadX as an RTOS backend and targets Eclipse Zenoh, Eclipse Cyclone DDS, and Eclipse uProtocol as gateway peers.
3. Vendor-neutral governance: The Eclipse IP process ensures clean provenance, which is essential for automotive supply chains spanning multiple OEMs and Tier-1s.
4. Specification alignment: The Open SOME/IP Specification Working Group provides a community governance model compatible with Eclipse Foundation processes.
5. Existing community ties: Contributors are active participants in the Eclipse SDV Working Group.
6. Complements, doesn't compete: OpenSOME/IP operates at the transport/middleware layer, below projects like Eclipse uProtocol and Eclipse Velocitas, enabling rather than duplicating their functionality.
Phase 1 (Months 1-3): Eclipse Foundation onboarding, IP review, repository migration.
Phase 2 (Months 4-6): Achieve >95% specification traceability, expand Zephyr board support, publish API documentation on Eclipse infrastructure.
Phase 3 (Months 7-12): Gateway companion project (Zenoh, DDS, gRPC bridges), AUTOSAR Adaptive alignment, performance benchmarking suite.
Phase 4 (Year 2): Interoperability test events with other Eclipse SDV projects, safety evidence package (ASIL-B prep)
Development follows an incremental model with monthly releases. The project is already at v0.1.0 with a proven CI/CD pipeline, so the initial Eclipse contribution focuses on IP clearance and governance alignment rather than greenfield development.
Key milestones post-contribution:
M1: Repository transferred to Eclipse GitLab/GitHub, ECA signed, initial IP review complete.
M2: First Eclipse release (v0.2.0) with expanded documentation and contributor onboarding materials.
M3: Gateway companion project proposed and bootstrapped.
M4: Interoperability demonstration with at least two other Eclipse SDV projects.
The project welcomes additional committers, especially those with expertise in:
- Automotive SOME/IP deployments at scale
- AUTOSAR Adaptive platform integration
- Zephyr RTOS networking
- Safety engineering (ISO 26262)
- Eclipse Foundation project management
Initial Contribution
The initial contribution includes the complete OpenSOME/IP codebase:
- ~27 core library source files implementing all protocol layers
- Platform abstraction backends for POSIX, FreeRTOS, ThreadX, Zephyr, and static allocation
- 15 C++ test suites (443 tests) + Python integration framework (80+ tests)
- 16 CI/CD workflows (GitHub Actions)
- 13 working examples (basic, advanced, E2E, cross-platform, RTOS)
- Zephyr module with 7 samples and 3 test suites
- Renode hardware simulation configurations (STM32F407, S32K388)
- Complete documentation: architecture, porting guides, API docs, requirements
- Open SOME/IP Specification (git submodule)
- RPM packaging (Fedora/RHEL via Packit)
All contributed code is Apache 2.0 licensed and will be reviewed to ensure compliance with Eclipse IP policies.
Source Repository Type: GitHub
Source Repositories:
- Implementation: https://github.com/vtz/opensomeip
- Specification: https://github.com/some-ip-com/open-someip-spec (submodule, under SOME/IP CSL 1.0)
- Log in to post comments