The Asset Administration Shell (AAS) is a central building block for interoperable Digital Twins in Industry 4.0. In practice, tool vendors, research projects, and industrial applications need reliable software building blocks for creating, validating, serializing, deserializing, packaging, and exchanging AAS data across different technology stacks.
AAS Core Works was created to address this need by maintaining machine-readable representations of published AAS meta-models and by using them as a single source of truth for generators, SDKs, schemas, test data, and developer tools. This approach reduces duplicated manual implementation effort across programming languages and helps keep implementations consistent when published AAS meta-models evolve.
The project already exists as an open source effort with multiple repositories, packages, generated SDKs, test data, and contributors from the AAS community. Moving the project to Eclipse is intended to provide neutral governance, stronger community visibility, and closer alignment with the Eclipse Digital Twin ecosystem.
The scope of Eclipse AAS Core Works is to provide reusable core libraries, generators, schemas, test data, and developer tooling for working with AAS based on published AAS specifications.
In scope are:
- machine-readable representations of published AAS meta-models;
- code and schema generators derived from these machine-readable meta-models;
- generated and maintained SDKs for creating, manipulating, verifying, serializing, and deserializing AAS models in multiple programming languages;
- serialization and schema artifacts such as JSON, XML, XSD, JSON Schema, Protobuf, OPC UA-related definitions, or similar artifacts where appropriate;
- libraries for reading and writing AAS package files;
- command-line tools, editor tooling, examples, documentation, and generated test data that support the development and validation of AAS-based software;
- maintenance work required to support new published versions of the AAS meta-model and related formats.
Out of scope are:
- defining, changing, or publishing the normative Asset Administration Shell specification itself;
- acting as an AAS specification project or standardization body;
- providing official certification or compliance marks for AAS products;
- implementing full AAS runtime infrastructure such as complete AAS servers, registries, repositories, cloud platforms, device connectivity stacks, or industrial middleware beyond what is needed to support the core libraries and tools;
- proprietary extensions that cannot be developed and maintained under open Eclipse governance.
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.
The project team is not aware of legal issues that would prevent contributing the existing code base to Eclipse under the MIT License.
The project name uses "AAS" as the common abbreviation for "Asset Administration Shell" in a descriptive way. The project does not claim ownership of the Asset Administration Shell specification, the "Asset Administration Shell" term, or any trademarks owned by IDTA, Plattform Industrie 4.0, Eclipse Foundation, or other organizations. The project will follow the applicable trademark and naming guidelines of the Eclipse Foundation and relevant third parties.
Eclipse is a natural home for AAS Core Works because the project provides foundational open source building blocks for Digital Twin software. The Eclipse Digital Twin community already brings together projects, companies, researchers, and users that work on interoperable Digital Twin infrastructure, including AAS-related software.
Hosting AAS Core Works at Eclipse provides neutral governance, transparent project processes, and better long-term sustainability for libraries and tools that are useful across organizations and technology stacks. The project can reduce duplicated effort in the AAS ecosystem by providing reusable, tested, and consistently generated core implementations.
The project is also complementary to existing Eclipse Digital Twin projects. AAS Core Works focuses on core model libraries, code generation, validation, serialization, package handling, schemas, and test data. Other Eclipse projects can build on these artifacts for higher-level runtime, repository, registry, server, integration, and application functionality.
Over the next twelve to eighteen months, the project intends to focus on the following activities:
- complete the transition of the initial contribution to Eclipse infrastructure and governance;
- establish automated builds, tests, release processes, dependency checks, and project documentation under Eclipse processes;
- align package metadata, namespaces, documentation, contribution guidelines, security information, and license notices with Eclipse requirements;
- maintain and improve support for currently published AAS meta-model versions;
- prepare the generator and SDKs for future published AAS meta-model updates;
- improve consistency across generated SDKs in supported programming languages;
- extend and harden validation, serialization, deserialization, package handling, and test-data generation;
- provide better examples and documentation for application developers and tool builders;
- explore interoperability examples with other Eclipse Digital Twin projects;
- grow the contributor and user community through GitHub issues, discussions, documentation, conference talks, AAS community channels, and collaboration with industrial and research users.
The project is expected to start with the existing public aas-core-works code base as the initial contribution.
The rough project schedule is:
- Project proposal and creation review: complete the Eclipse project proposal, identify initial committers, and perform the required Eclipse project creation steps.
- Initial contribution: contribute the existing aas-core-works repositories, including the core meta-model representations, code generator, generated SDKs, package libraries, schemas, tools, tests, and documentation selected for the initial Eclipse scope.
- Project setup: configure Eclipse-hosted repositories or repository transfer, issue tracking, CI builds, license headers, contribution guidelines, security information, and release metadata.
- First builds: establish reproducible builds and automated tests for the main repositories after the initial contribution has been accepted.
- First incubation release: prepare an initial Eclipse incubation release after the required IP checks, dependency reviews, build setup, and project metadata updates have been completed.
- Ongoing releases: provide regular releases aligned with improvements in the project and updates to published AAS meta-model versions.
The following individuals, organizations, companies, and projects have expressed interest in this project:
- ZHAW (Zurich University of Applied Sciences - Institute of Mechatronic Systems (IMS))
- Fraunhofer IESE (Fraunhofer IESE)
- conplement AG (conplement AG)
- RWTH Aachen University (RWTH Aachen - Chair of Information and Automation Systems for Process and Material Technology)
- Industrial Digital Twin Association (IDTA) (Industrial Digital Twin Association)
- TU Dresden (TU Dresden - Chair of Industrial Communications)
There are potentially more but I can't confirm that officially right now.
The initial contribution consists of the existing aas-core-works code base currently hosted in public GitHub repositories. The contribution includes machine-readable AAS meta-model representations, the aas-core-codegen generator, generated SDKs for multiple programming languages, schemas and serialization artifacts, package handling libraries, command-line and editor tooling, examples, documentation, and generated test data.
A significant part of the SDK code is generated from machine-readable AAS meta-model representations. The handwritten parts include the generator infrastructure, language-specific generation logic and snippets, package libraries, tools, tests, examples, and documentation. The generated SDKs provide functionality for creating, manipulating, verifying, serializing, and deserializing AAS data. Package libraries provide support for reading and writing AAS package files.
The existing project has an active community around the aas-core-works repositories, including individual contributors and contributors associated with organizations active in the AAS ecosystem. The current contributors have been contacted and support moving the project to Eclipse. Copyright is currently held by the existing contributors and, where applicable, their employers or affiliated organizations as reflected in repository history, author metadata, copyright notices, and related project files. Copyright and provenance information will be reviewed and normalized as part of the Eclipse onboarding and IP due diligence process.
Representative third-party dependencies identified at proposal time include:
- Python/build/codegen dependencies: setuptools, wheel, setuptools-scm, asttokens, icontract, sortedcontainers, docutils, more-itertools, greenery, and typing_extensions.
- TypeScript dependencies: xmlsax-typescript as a runtime dependency in the TypeScript SDK, plus development/build/test dependencies such as TypeScript, Babel, Rollup, Jest, ts-jest, ESLint, Prettier, TypeDoc, rimraf, cross-env, @xmldom/xmldom, and related type packages.
- C++ dependencies: vcpkg-cmake, vcpkg-cmake-config, nlohmann-json, Expat, tl-optional, tl-expected, and Catch2 for tests where applicable.
- Go package libraries are currently documented as pure Go libraries without external dependencies beyond the Go standard library.
Preliminary associated licenses include MIT for the aas-core-works project artifacts, MIT for several build/runtime dependencies, Apache-2.0 for selected Python dependencies, CC0-1.0 for tl-optional and tl-expected, BSL-1.0 for Catch2, and the respective upstream licenses of package-manager, build, documentation, and test dependencies. The final dependency and license inventory will be generated from the actual contributed repositories and reviewed through the Eclipse IP process before the first Eclipse release.
- Log in to post comments