Proposals

AI coding agents are most useful when they can act autonomously: run commands, install packages, edit files, and iterate without asking for permission at every step. Granting that autonomy directly on a developer's host machine is risky: agents can damage system files, leak secrets, fall victim to prompt injection, or interfere with one another when running in parallel. Most organizations have no consistent way to constrain or audit what their agents actually do.

Eclipse Enclave addresses this gap by providing a sandboxed runtime in which agents operate inside isolated containers (and, in the future, microVMs or other isolation backends) with their own filesystem, process tree, and network stack. A sidecar gateway restricts outbound network traffic to allowlisted domains and records what each agent reached out to. Multiple agents work in parallel without interfering with each other by operating on separate Git worktrees of the same project. Auth, configuration, and history persist across restarts under user control. A control center surfaces the state of all running agents and provides a single place to start, stop, inspect, and review their work.

The same isolation, logging, and policy infrastructure that makes agentic development safer for individual developers also produces the evidence and controls needed by organizations to operate agents responsibly: per-session audit trails, network access logs, dependency provenance records, and policy enforcement points that map to requirements emerging from the EU AI Act and the EU Cyber Resilience Act.

Eclipse Enclave deliberately separates agent execution from agent identity. It treats agents as pluggable workloads behind a common runtime, configuration, and policy surface. This lets the community focus on isolation, observability, governance, and integration — and lets adopters mix and match agents and editors without rebuilding the surrounding infrastructure each time.

In summary, the Eclipse Particle Cloud Security (PCS) project provides vendor-neutral, open source technology for multi-provider storage protection, improving data sovereignty by ensuring no single provider can recover customer plaintext from its store alone, while supporting recovery and embedding in existing storage software and services.

Eclipse Bucky is a lightweight Java S3 client with no 3rd party dependencies. It is designed to be minimal and easy to use, providing a straightforward interface for interacting with Amazon S3 compatible services.
After much searching we could not find a Java S3 client that did not have a large number of dependencies. This client only uses the Java standard library.

Eclipse SSAM is a lightweight container execution framework optimized for automotive ECU environments in the context of Software-Defined Vehicles (SDV). It rapidly initializes container environments to begin application execution, and continuously verifies the integrity of container packages to detect tampering or unauthorized modifications in real time.

The framework provides the following core capabilities:

• Package Management — supports installation, removal, and upgrade of container packages
• Integrity Verification — ensures package integrity using Linux dm-verity and EROFS
• Container Execution — runs containers via an OCI-compatible container runtime (crun) using Systemd
• Resource Isolation — in addition to the resource isolation provided by OCI Runtime, enforces ext4 project quota on writable data partitions to limit disk usage per container-native application

Unlike conventional OCI-compliant solutions, Eclipse SSAM is purpose-built for resource-constrained, safety-critical systems where fast startup and tamper detection are essential. It selectively adopts OCI concepts while prioritizing performance and security over full specification compliance.

Eclipse SSAM operates on Linux-based host operating systems and relies on externally provided low-level runtimes, focusing solely on efficient container execution in constrained environments.

By open-sourcing SSAM under the Eclipse Foundation, we aim to foster cross-industry collaboration and contribute to a robust, scalable vehicle software ecosystem.

Eclipse KeySealer provides an open source KMS plugin for Kubernetes encryption at rest.

The initial implementation is based on k8s-kms-plugin, a gRPC service that implements the Kubernetes KMS v2 API and connects Kubernetes to a local or remote PKCS #11-capable key store. The plugin enables Kubernetes clusters to protect API data, such as Secrets, by using a key encryption key stored in an HSM, TPM-backed provider, software token, or external key manager exposed through PKCS #11.

Eclipse KeySealer is intended to provide a vendor-neutral home for Kubernetes KMS integrations with hardware-backed and externally managed keys. It helps Kubernetes operators use protected keys without depending on a single cloud provider, hardware vendor, or proprietary key-management integration.

The project is designed for production-oriented Kubernetes deployments where data-at-rest encryption, key isolation, key rotation, auditability, and interoperability with existing cryptographic infrastructure are important requirements.

Eclipse KeyPont is a collection of Go libraries for applications that need to use protected cryptographic keys, cryptographic tokens, and standard cryptographic protocols.

The project provides Go developers with reusable building blocks for integrating hardware security modules, PKCS #11 devices, key-management systems, and JOSE-based application protocols into Go software. The libraries are designed to be idiomatic for Go developers, to work with standard Go cryptography interfaces where appropriate, and to provide clear examples for common use cases such as signing, decryption, token-backed keys, JWT handling, and JOSE object processing.

Eclipse KeyPont provides a vendor-neutral home for these libraries under Eclipse Foundation governance. The project is intended to encourage broader collaboration among users, maintainers, device vendors, cloud providers, and application developers who need interoperable cryptographic integrations in Go.

The Eclipse Dataspace Hub is a community-driven enablement project that lowers the entry barrier for developers and organizations adopting dataspace technologies, such as the Eclipse Dataspace Components (EDC), the Connector Fabric Manager (CFM), or Data Plane implementations.

The project addresses key challenges facing dataspace newcomers: fragmented documentation, scattered repositories, and a lack of hands-on examples. It is structured around three complementary areas: (1) a comprehensive library of sample code and reusable templates provides reference implementations for common EDC extensions and integration examples with external systems; (2) fully functional end-to-end demonstrators illustrate realistic cross-organizational data sharing scenarios; (3) a centralized, community-maintained knowledge base consolidates core concepts, architectural patterns, and operational guidance in one accessible location.

What it is not: The project does not engage in core dataspace specification development or maintain production-grade code. It focuses exclusively on education, enablement, and demonstration. Any enhancements or bug fixes identified during sample development are contributed upstream to the appropriate repositories.

The project builds upon existing Eclipse dataspace technologies and aligns with prominent dataspace initiatives to foster interoperability across data ecosystems.

Eclipse Canon-C is a header-only semantic standard library for C99 targeting safety-critical embedded systems. It provides explicit ownership annotations, Result and Option types, arena allocation, fixed-capacity collections with caller-owned buffers, traceable contracts, and a coherent error-handling model — all designed for formal verification with Frama-C and certification under DO-178C, ISO 26262, IEC 62304, IEC 61508, EN 50128, and ECSS-E-ST-40C.

The library follows a strict dependency hierarchy: core/primitives → core → semantics → data → algo → util. Each layer is complete and independently usable. The core layers are freestanding-safe, with no RTOS, OS, or libc dependencies, allowing Eclipse Canon-C to run on bare metal, on Eclipse ThreadX, or alongside any other RTOS including FreeRTOS and Zephyr.

Eclipse Canon-C's continuous integration pipeline produces certification evidence as a normal part of every commit: 51 test binaries across GCC, Clang, and MSVC on three platforms; AddressSanitizer and UndefinedBehaviorSanitizer in every Debug build; Valgrind memory analysis; libFuzzer fuzzing; clang-tidy and Cppcheck static analysis; MISRA C:2012 advisory checks; and true Modified Condition/Decision Coverage measurement using GCC 14's -fcondition-coverage flag. The verification infrastructure is in place; ACSL annotations and Frama-C proofs are the next planned milestone.

Eclipse PanEval is an open-source large model evaluation platform and framework, designed to establish scientific, impartial, and open evaluation benchmarks, methodologies, and toolsets. It comprehensively assesses foundation model performance across language, multimodal, vision, and speech domains.

Core framework: A three-dimensional evaluation system based on "Capacity – Task – Metrics":
- Capacity: defines the scope of model capabilities ("What to evaluate?")
- Task: the form used to assess model capabilities ("How to evaluate?")
- Metrics: quantitative assessment from multiple perspectives ("How to measure?")

Eclipse PanEval covers 4 major model categories and 40+ evaluation tasks, with Safety & Robustness as a cross-cutting evaluation dimension for all categories.

Eclipse Timpani is a real-time scheduling framework designed for AI-Defined Vehicle (AiDV) applications. As a submodule of the Eclipse Pullpiri orchestrator, Timpani focuses on ensuring deterministic execution of real-time workloads where timing predictability is critical.

Timpani implements Time-Triggered Scheduling based on Time-Triggered Architecture (TTA) principles, proven approaches used in avionics and automotive safety-critical systems, executing tasks based on static schedule tables at predetermined periods with strict timing guarantees. The framework leverages Linux real-time scheduling policies (SCHED_FIFO, SCHED_RR) for priority-based task management, while providing eBPF-based observability for non-intrusive monitoring of scheduler behavior including wakeup latency and execution statistics.

The distributed architecture separates orchestration (Timpani-O) and execution (Timpani-N) components, enabling Pullpiri to manage real-time workloads across multiple nodes through declarative YAML-based configuration.

Key Features:

• Time-Triggered Execution: Deterministic periodic task dispatching
• Distributed Architecture: Separation of global scheduler (O) and node executor (N)
• eBPF Observability: Runtime visibility into scheduling behavior with minimal overhead
• Pullpiri Integration: Seamless orchestrator integration via gRPC services
• Mixed-Criticality Support (Planned): Coexistence of workloads with varying safety levels