# SystemC is a C++ class library, not a simulator > The Accellera SystemC class library gives hardware engineers a way to model a system in ANSI C++, with the API and semantics standardised as IEEE Std. 1666-2023. This repository is the reference implementation, which means it is the thing the standard describes, and the thing to read when a tool and the standard disagree. **accellera-official/systemc** — SystemC Reference Implementation - Repository: https://github.com/accellera-official/systemc - Website: https://systemc.org/overview/systemc/ - Stars: 697 · Forks: 206 - Language: C++ - License: Apache-2.0 - Published: 2026-10-21 · Updated: 2026-10-21 · Language: en - Canonical page: https://hysenlabs.com/projects/accellera-official-systemc ## A language that spans hardware and software, delivered as C++ classes The problem the project names is a need for a system design and verification language that spans hardware and software, and the answer is a language built as an ANSI C++ class library created for design and verification. That phrase carries the whole architecture. SystemC is not a new compiler and not a simulator with its own input language. It is a set of C++ classes, so a model is an ordinary C++ program, and the standardisation follows from that choice rather than replacing it. The README states that the SystemC API and its semantics are developed by the Accellera Systems Initiative and formally standardized and governed by the IEEE in the IEEE Std. 1666-2023 standard. The list of what users apply it to is long and covers the whole system level: system-level modeling, abstract analog and mixed-signal modeling, architectural exploration, performance modeling, software development, functional verification, and high-level synthesis. The audience is therefore hardware and system architects who need to explore a design before it is RTL, and verification engineers who need a model of the environment to test against. The language is C++ and the topics carry tlm alongside cpp and systemc, which is the transaction level modeling family that the class library was built to support. ## The standard is definitive, and this is where you read the details The README states a rule that decides most support questions. In the event of discrepancies between the behavior of this implementation and statements made in the IEEE Std. 1666-2023 standard, the IEEE standard shall be taken to be definitive. That sentence inverts the usual relationship between a library and its documentation, and it has practical consequences. When a commercial tool built on SystemC behaves differently from what you expected, the reference implementation is not the authority either. The standard is. This repository is where you go to understand the semantics, but the arbiter is a document you may have to buy. The reference implementation is provided by the Accellera Systems Initiative and is mainly developed by two working groups, the SystemC Language Working Group and the SystemC Datatypes Working Group. The README explains that the Language Working Group is responsible for the definition and development of the SystemC and TLM core languages, the foundation on which all other SystemC libraries and functionality are built, and that participants include member companies and industry contributors with many years of practical experience in IC and system design and in developing and using EDA tools. The main documentation of SystemC is the IEEE Std. 1666-2023 Standard SystemC Language Reference Manual, and the repository's docs directory holds additional documentation for this release, some of which refers to older versions. ## Getting the source, the examples and the build for your platform The README is deliberately thin on installation and delegates the details. It says to see the separate INSTALL.md file that provides system information and installation instructions, and to see the separate RELEASENOTES.md file for up to-date information about this release. So the installation content of this project lives in two files rather than in the README, which is a detail worth knowing before you start looking for a configure script in the wrong place. The top level listing shows a build setup that covers the ways people actually build C++ projects. There is a CMakeLists.txt at the root with a cmake/ directory, an Autotools path with configure.ac and Makefile.am, a config/ directory, a docker/ directory, an msvc16/ directory for Visual Studio, a src/ directory holding the library sources, and a tests/ directory. The .gitmodules entry suggests submodules are used, which is common when the examples or the test data carry their own repositories. The examples directory has its own CMakeLists.txt and Makefile.am, with build-msvc/ and build-unix/ subdirectories and two sample trees named examples/sysc/ and examples/tlm/, so the transaction level side of the library has worked examples separate from the core SystemC ones. A second README exists inside that tree, which is where the example walkthroughs live. If you are coming from another language, the TLM examples are the place to start, because the transaction level interface is the layer that connects a functional model to a timing model. ## A standards body artefact, not a product with a support desk The governance is visible in the repository, and it changes what you can expect from it. The licence is Apache-2.0, and the README directs you to the separate LICENSE and NOTICE files to determine your rights and responsibilities for using SystemC, which is the correct thing to read rather than assuming from a badge. The NOTICE file exists because a reference implementation carries the copyright of the contributors and the organisations involved, and that attribution travels with any distribution. Beyond the files, Accellera Systems Initiative is described as an independent, not for profit organization dedicated to create, support, promote and advance system level design, modeling and verification standards for use by the worldwide electronics industry, and its role in the standard is specific, since as part of its ongoing partnership with the IEEE its standards are contributed to the IEEE Standards Association for formal standardization and ongoing change control. The practical consequences are two. First, the code is Apache-2.0, which is about as permissive as a standards body artefact gets, so embedding it in a commercial tool is straightforward. Second, there is no vendor behind it to escalate to. The community channels are the SystemC community website at systemc.org and a community discussion forum at forums.accellera.org, and the README notes that SystemC, Accellera and Accellera Systems Initiative are trademarks of Accellera Systems Initiative Inc. ## What the reference implementation is and is not for you Two limits are worth naming before you build a flow on it. The first is that the library is not the tool. The README lists high-level synthesis among the application areas, but a class library does not synthesise anything by itself, and nothing in the repository describes a synthesis tool, a simulator or an environment that would execute a SystemC model. What this repository gives you is the class library, its tests, its examples and its documentation, and if you want a simulator you have to pair it with one, which is exactly the arrangement most commercial flows use. The second limit is the version gap. The standard that governs the semantics is the 2023 revision, and this repository is the implementation of that standard, but the repository's own release naming is separate from the standard's numbering, so a project that mixes SystemC code with a commercial simulator has to be checked against the standard revision the simulator targets as well as the revision you built against. A third, quieter limit is the reference nature of the code itself. A reference implementation is written to be correct and complete against the standard, not to be the fastest or the most convenient, and the working groups structure implies that behaviour changes land through standard proposals rather than through fast iteration. If your requirement is a fast model for an exploratory spike, the class library is the wrong shape for that job. ## Where it sits against the other ways to model a system There are three other routes to the same goal, and they differ in where the model lives. The first is writing the model by hand in plain C++ with no library, where you control every line and the model compiles anywhere a compiler does, at the cost of inventing the module, port, channel and process concepts yourself and losing the standard semantics that other tools can rely on. The second is a vendor modelling kit, where a commercial supplier ships its own class library and its own simulator, which means the semantics are the vendor's rather than a published standard's, and the model is tied to that vendor's tool versions and licensing. The third is RTL simulation, where the design is written in a hardware description language and the cycle accuracy is real but the modelling effort is high, since a system level view has to be reconstructed from block level descriptions. SystemC sits between the first and the second. It gives you the C++ you already have, plus a class library whose semantics are fixed by IEEE Std. 1666-2023, so a model written against it is portable across implementations in a way that a vendor kit's model is not, and the transaction level interfaces are what let the same source move from a functional model to a timing model as the design matures. The cost is that you still need an execution environment, and that the standard is a document you may have to purchase rather than a tool you can download. ## Conclusion Take the SystemC reference implementation if you are modelling a system in C++ and want an API whose semantics are fixed by a published IEEE standard, since the library is free of a simulator around it and the standard settles every question a vendor tool might answer differently. Do not take it if your work is at RTL level, since this is a modelling and verification library rather than a simulator or a synthesis tool, and do not take it if you need commercial support, since the repository is a standards body artefact with issues raised through the community forum. Before you build on it, read INSTALL.md in the repository, since the README delegates all installation detail to that file, and check RELEASENOTES.md for the release you take, because the version in use is what the standard refers to and the standard took its most recent form in 2023. ## FAQ ### What is the SystemC class library? SystemC is a language built as an ANSI C++ class library created for design and verification, used for system level modeling, architectural exploration, performance modeling, functional verification and high level synthesis. Its API and semantics are developed by the Accellera Systems Initiative and standardized as IEEE Std. 1666-2023. ### Is the SystemC reference implementation a simulator? No. The repository is the reference implementation of the SystemC class library, with sources, tests, examples and documentation. The README lists high level synthesis among the application areas of the language, but the library itself is the modelling layer, and an execution environment comes from elsewhere. ### Where are the SystemC installation instructions? The README refers you to a separate INSTALL.md file in the repository for system information and installation instructions, and to a separate RELEASENOTES.md for what changed in this release. The build supports CMake, Autotools, Visual Studio through an msvc16 directory, and a docker/ directory. ## Sources - [accellera-official/systemc on GitHub](https://github.com/accellera-official/systemc) - [Issues](https://github.com/accellera-official/systemc/issues) - [License: Apache-2.0](https://github.com/accellera-official/systemc/blob/main/LICENSE) - [Project website](https://systemc.org/overview/systemc/) - [README](https://github.com/accellera-official/systemc/blob/main/README.md) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/accellera-official-systemc