Release notes

A list of new and noteworthy features as well as bugs we have tackled down in the particular releases.

itemis CREATE 5.5.0 (September 17, 2025)

This release mainly fixes Java simulation bugs and compatibility issues with the supported Eclipse platforms. It also delivers a newly added feature for the C# code generator.

C# code generator

For more information see: https://www.itemis.com/en/products/itemis-create/documentation/user-guide/codegen_csharp_code_generator#codegen_csharp_tracing_feature

Java domain simulation

Fixed several issues when java domain statecharts and external java source are used for simulation:

Validation and Modeling

Miscellaneous

Target platform

IMPORTANT NOTICE: As there was an EMF bug bundled with the Eclipse 2025-06 release the latest version of GMF Runtime SDK is required (1.8.0.202508120942).
It is shipped with the release train (https://download.eclipse.org/releases/latest) so installing CREATE with the default Available Software Sites the installation should pull it automatically.
In other cases it could be installed from https://download.eclipse.org/modeling/gmp/gmf-runtime/updates/releases/

itemis CREATE 5.4.0 (August 1, 2025)

This release provides a now fully completed C# code generators along with improvenets and bugfixes in several areas.

Multi-state machine support for C#

The C# code generator now fully supports multi-state machine scenarios, enabling correct and complete code generation when multiple state machines are defined.The C# code generator is now feature complete regarding common statechart and sctunit generator features.

SCTUnit Generator

C++ Code Generator

Deep C/C++ Integration

C# Code Generator

Validation and Modeling

Customization & API

Miscellaneous

itemis CREATE 5.3.0 (April 16, 2025)

This release mainly fixes compatibility issues with the supported Eclipse platforms. It contains the following changes:

Additionally, these issues were fixed:

IMPORTANT NOTICE: Users of floating servers are required to update their license server as a precondition to use this and newer releases.

itemis CREATE 5.2.5 (January 24, 2025)

This release mainly fixes compatibility issues with the supported Eclipse platforms. It contains the following changes:

Additionally, these issues were fixed:

itemis CREATE 5.2.4 (December 23, 2024)

This release contains the following changes:

Additionally, these issues were fixed:

itemis CREATE 5.2.3 (July 5, 2024)

This release contains the following main features:

This release contains the following changes:

Additionally, these issues were fixed:

itemis CREATE 5.2.2 (March 22, 2024)

This release contains the following main features:

For examples and more info: https://blogs.itemis.com/en/deep-java-integration-for-yakindu-state-machines

This release contains the following changes:

Additionally these issues were fixed:

itemis CREATE 5.2.1 (December 22, 2023)

This release contains the following changes:

Additionally these issues were fixed:

itemis CREATE 5.2.0 (November 2, 2023)

This release contains the following main features:

Additionally the following issues and bugs were fixed.

itemis CREATE 5.1.1 (August 11, 2023)

This release contains the following changes:

itemis CREATE 5.1.0 (April 24, 2023)

This release contains the following fixes and improvements:

itemis CREATE 5.0.0 (Dec 22, 2022)

This is a new major release. The name YAKINDU Statechart Tools (YSCT) will be discontinued and replaced by itemis CREATE. From a functional point of view this release is compatible with previous releases. It is provided as the part of the regular tool maintenance. So no changes apply in regards to license handling.

YAKINDU Statechart Tools 4.1.2 (Jul 11, 2022)

This release contains the following fixes and improvements:

YAKINDU Statechart Tools 4.1.1 (Jun 15, 2022)

This release contains the following fixes and improvements:

YAKINDU Statechart Tools 4.1.0 (May 9, 2022)

The 4.1 release is a major release that adds Completion Transitions semantics to CREATE Statecharts, and comes with a first preview of the new C++ 11 Code Generator.

Completion Transitions

From this version onwards, YAKINDU Statechart Tools applies the UML specification for completion transitions as defined in the OMG UML 2.5.1 specification under chapter 14.2.3.8.3. Completion transitions are transitions that do not declare any trigger or guard. In previous versions such empty transitions were never taken and a corresponding warning was displayed.

A completion transition is taken as soon as its source state is completed. A simple state is considered to be completed when all its entry actions are executed. A composite/orthogonal state is considered to be completed when all its sub regions have reached a final state. Completion transitions make it much easier to synchronize the execution of parallel actions in orthogonal regions. A sub machine state is completed when the sub statemachine has reached its final state. However, the latter case is not yet supported, but will be implemented in the near future.

You can find more information on this feature in our user documentation.

(Beta) C++ 11 Code Generator

In addition to the existing C++98 compliant code generator this release provides a beta version of a C++11 compliant code generator. C++11 was chosen as the base standard which fits very well into recent C++ standards.

The current version is intensively tested and can be used for production code. But please be aware that this version is beta. The API of the generated state machine code may change until the final release.

The main differences to the C++98 code generator relate to c++11 compliant changes to the generated state machine API:

You can use the C++11 code generator by specifying create::cpp11 instead of create::cpp in your *.sgen files. Accordingly the C++11 SCTUnit code generator uses the generator id sctunit::cpp11.

(Beta) Reworked Qt-C++ Code Generator

The Qt code generator has been reworked to use the new C++ 11 code generator. While doing so we have fixed several issues that were present in the previous Qt generator. You can install the Qt code generator from the release update site (under the category “YAKINDU Statechart Tools Extensions”).

Further Updates

This release contains the following updates:

YAKINDU Statechart Tools 4.0.9 (Jan 24, 2022)

This release contains the following fixes and improvements:

YAKINDU Statechart Tools 4.0.8 (Sep 21, 2021)

This release contains the following bugfixes:

YAKINDU Statechart Tools 4.0.7 (Jul 09, 2021)

This release contains the following bugfixes:

YAKINDU Statechart Tools 4.0.6 (Apr 16, 2021)

This release contains several bugfixes:

YAKINDU Statechart Tools 4.0.5 (Feb 08, 2021)

This release contains the following new features:

In addition, the following issues were fixed:

YAKINDU Statechart Tools 4.0.4 (Dec 04, 2020)

This release contains several bugfixes, new examples and documentation updates:

Documentation

Examples

New examples and new example structure

YAKINDU Statechart Tools 4.0.3 (Nov 13, 2020)

This release contains several bugfixes as well as improvements for the Python code generator:

YAKINDU Statechart Tools 4.0.2 (Nov 06, 2020)

This is mainly a bugfix release, containing several fixes for our code generators and the YET infrastructure, but also some usability improvements.

Code Generation

In this release we added new feature for the C and C++ code generators: It is now possible to generate a software timer service implementation by using the ‘timerService’ parameter in the generator model, like in the example below:

Example:

feature GeneralFeatures {
    timerService = true
}

Furthermore, we fixed several issues, among others:

YET Infrastructure

For this release, we also spent some effort in further improving the CREATE Execution Trace (CET) infrastructure:

Editor Usability and Other Fixes

YAKINDU Statechart Tools 4.0.1 (Oct 20, 2020)

This is mainly a bugfix release, containing the following:

YAKINDU Statechart Tools 4.0.0 (Oct 09, 2020)

YAKINDU Statechart Tools 3.5.13 (Sep 04, 2020)

This is mainly a bugfix release, containing the following:

YAKINDU Statechart Tools 3.5.12 (Jun 15, 2020)

This is mainly a bugfix release, containing the following:

SCXML

In this release we also put some effort in improving the SCXML integration, containing the following:

YAKINDU Statechart Tools 3.5.11 (Apr 07, 2020)

This is mainly a bugfix release, containing the following:

YAKINDU Statechart Tools 3.5.10 (Feb 24, 2020)

This is mainly a bugfix release, containing the following:

YAKINDU Statechart Tools 3.5.9 (Nov 14, 2019)

This is mainly a bugfix release, containing the following:

Documentation

For this release we also spent some additional time on our documentation. We restructured the user-guide and updated some parts. We also added two new chapters:

YAKINDU Statechart Tools 3.5.8 (Oct 10, 2019)

This is mainly a bugfix release, containing the following:

Example Wizard

We have restructured the examples from the example wizard and added new ones. Please make sure that you update your examples (click on Update button in example wizard) in order to benefit from the new structure. In particular, we added new examples to explain some more advanced statechart concepts like histories, statechart hierarchies, orthogonality and our execution schemes (event-driven, cycle-based, parent-first, child-first). In addition we added new simple examples for code generation in C, C++ and Java.

New examples and new example structure

YAKINDU Statechart Tools 3.5.7 (Sep 16, 2019)

This is a bugfix release, containing the following:

YAKINDU Statechart Tools 3.5.6 (Sep 3, 2019)

This is a bugfix release, containing the following:

YAKINDU Statechart Tools 3.5.5 (June 18, 2019)

This is a bugfix release, containing the following:

YAKINDU Statechart Tools 3.5.4 (May 15, 2019)

This is a bugfix release, containing the following:

Event-driven execution support for C# code generator

The C# code generator now also supports statecharts with event-driven execution semantics. The generated code now contains corresponding run-cycle calls when events are triggered as well as a queue for internal events.

YAKINDU Statechart Tools 3.5.3 (Mar 29, 2019)

This release adds in-event queue support for C and Java code generators as well as some usability improvements.

In-event queue support for C and Java code generator

Similar to the C++ code generator, C and Java code generators now also support an additional event queue for incoming events if the statechart is event-driven. To enable it, set the inEventQueue option of the GeneratorOptions (in Java GeneralFeatures) to true. If an operation callback or function is executed by the state machine and that function raises an event, this event will be appended to the in-event queue. The state machine’s API will remain unchanged. After the origin event was processed, all events in the in-events queue will be processed automatically in the order they were raised.

Usability

We added two more buttons to the simulation view to easier restart simulation runs:

The generator model now suggests a quick fix in case the specified target project does not exist:

Quickfix for changing project name

Miscellaneous

In addition, this release contains the following changes:

YAKINDU Statechart Tools 3.5.2 (Feb 28, 2019)

This release focuses on stability and performance, especially in the C/C++ domain.

C/C++ Domain

The transformation of C/C++ code does not rely on the C/C++ indexer to be finished anymore. Especially in C++ projects, the side effects were sporadically unresolved types. When the transformation is invoked while the C/C++ indexer is running, indexer information is discarded and header files get parsed again. This also means that SCT can be used with the C/C++ indexer being disabled, which is in some cases necessary due to performance reasons.

We also improved the runtime performance of the C/C++ transformation dramatically which is particularly noticeable in C++ projects with the C/C++ indexer being disabled.

The C/C++ code generator now prints includes in the same order as they are defined in the statechart model. In that way, the user can influence the generated include order directly in the statechart model. The code generator also does not resolve symbol links on its own anymore.

The content assist for import statements shows header files from the workspace first, before showing system headers.

Generator Model Wizard

We added an option to install more generators from within the generator model wizard. Using this option, the install wizard opens with a list of available code generators from our Labs update site.

Install more generators

Example Wizard

The examples delivered with YAKINDU Statechart Tools now contain information about requirements to other features. This information is read out in the example wizard and an Install Dependencies button is shown if a required features are missing. Clicking on this button opens the install wizard with the required features being preselected.

Install Dependencies button in example wizard

Java Domain (Beta)

It is now possible to use inner classes and enumerators in Java domain statecharts.

We removed some useless entries from the content assist. The content assist for import statements shows own Java classes first, before showing JRE classes.

Miscellaneous

In addition, this release contains

YAKINDU Statechart Tools 3.5.1 (Feb 04, 2019)

This release focuses on stabilization of the SCXML and Java domains.

SCXML Domain

Statecharts with multiple choices in different composite states are now handled properly.

We also fixed a bug in the simulation of SCXML statecharts in which execution slots could not be properly resolved.

Java Domain

We added a bunch of new features to the Java domain and also improved performance and stability.

We added target type inference to our type system. This means, you can now write the following:

var song : Optional<Song> = Optional.empty()

In this case, the type inferer will deduce that Optional.empty() returns an Optional of type Song.

Java class constructors are now transformed into static new(...) methods. This means, you can now create new objects like this: 

var song : Song = Song.new("mysong.wav")

Changes in imported Java classes are now directly reflected in the statechart, so you do not need to re-load the statechart model anymore.

We also improved the performance of the Java domain significantly, so it can be finally used in larger projects.

Miscellaneous

In addition, this release contains

YAKINDU Statechart Tools 3.5.0 (Jan 22, 2019 )

This release adds a rich set of new and noteworthy features:

Eclipse platform

We upgraded the underlying Eclipse platform to the new Eclipse 09-2018 release. This will be the last release of YAKINDU Statechart Tools that supports 32-bit versions since the Eclipse Foundation decided to drop 32-bit with the 12-2018 release ( https://bugs.eclipse.org/bugs/show_bug.cgi?id=536766 ). However, you will still be able to install YAKINDU Statechart Tools into an older 32-bit Eclipse version via our update site - only the bundled products won’t support 32-bit in the future.

Deep Java integration (beta)

After more than a year of work, we are proud to present the first beta release of deep Java integration in YAKINDU Statechart Tools. It allows you to directly access Java APIs in your statechart, and it hence facilitates an incorporation of state machine modeling in your Java development process. The beta version contains the following features:

You can read more and watch a video in the following blog post:

https://blogs.itemis.com/en/statechart-modeling-for-java-development .

Tracing callbacks for C++ and Java

The tracing feature enables the generation of tracing callback functions for Java and C++. We added a new feature to the generator model where you can configure the tracing events you are interested in:

feature Tracing {
  enterState = true
  exitState = true
}

The enterState parameter specifies whether to generate a callback function that is used to notify about state-entering events, and the exitState parameter specifies whether to generate a callback that is used to notify about state-exiting events.

Qt C++ code generator

With the SCXML domain ( https://blogs.itemis.com/en/taking-scxml-to-the-next-level-with-yakindu-statechart-tools ), we already have a powerful and flexible way to integrate YAKINDU Statechart Tools into Qt ( https://www.qt.io/ ) applications. But there are still use cases where you can’t use the Qt SCXML Interpreter. That is why we started the development of a Qt C++ code generator and released a first version via our YAKINDU Statechart Tools labs update site.

The Qt specific flavor of the C++ code generator makes use of Qt signals and slots. So the generated state machine can easily be integrated into Qt applications using this mechanism. The generated statemachine inherits from QObject. _A _QTimer-based implementation of a timer service is generated, if the statechart makes use of time triggers.

An example of the Qt C++ code generator together with a simple QML user interface is available via our example wizard.

In-event queue support for C++ code generator

The C++ code generator now also supports an additional event queue for incoming events if the statechart is event-driven. To enable it, set the inEventQueue option of the GeneratorOptions feature to true. If an operation callback or function is executed by the state machine and that functions raises an event, this event will be appended to the in-event queue. The state machine’s API will remain unchanged. After processing of the origin event is completed, all events in the in-events queue will be processed automatically in the order they were raised.

To enable the in-event queue, add the following generator option to your .sgen file: 

feature GeneratorOptions {
  inEventQueue = true
}

Miscellaneous

YAKINDU Statechart Tools 3.4.0 (Aug 20, 2018)

This release comes with a pile of new cool features:

The larger the model, the greater the need to quickly search for elements, for example, all states with a given name resp. name pattern, all occurrences of a certain variable, etc. This is now possible with the new model search integrated in the Eclipse search dialog:

The model search allows you to use regular expressions and to filter for the kind of elements you want to search for. Once the search is performed, its results are listed in the search view where you can quickly navigate to the corresponding statechart elements.

A similar but slightly different use case is to search for all references of an element. You can find this option now in the context menu. The results will be listed in the same view as for the standard model search.

SCXML Domain

This version of YAKINDU Statechart Tools comes with an SCXML domain made to facilitate generating SCXML files from CREATE Statecharts. SCXML, short for Statechart XML, is a statechart interchange format based on XML, standardized by the W3C . All states, events, variables and so on are defined in the XML. SCXML relies on external engines to execute the statechart according to the standard, which allows a statechart defined in SCXML to be highly portable. Like other XML based formats, it is only an interchange format and hence not really suitable for direct editing.

YAKINDU Statechart Tools Professional Edition with its SCXML domain allows you to design and verify statecharts exactly according to the SCXML standard. The built-in simulation engine of YAKINDU Statechart Tools Professional Edition was adopted to reflect the execution semantics of SCXML correctly. And of course, the SCTUnit framework takes the SCXML domain into account as well, so you can be sure that the test results reflect the behavior of the SCXML engine of your choice.

To see everything in action we have added an example to our example wizard. This example was taken from the Qt examples and modeled with YAKINDU Statechart Tools. It contains a traffic light statechart which is on-the-fly transformed into an SCXML file. You can edit, simulate and test the statechart as you are used to in YAKINDU Statechart Tools. Additionally, the example comes with some Qt code, so you can run it in your Qt environment and see the traffic light in action.

Speaking of our example wizard, we also put some effort here to provide a cleaner, more structured appearance.

SCTUnit for C Domain

We have adopted our testing framework SCTUnit to also work with C domain statecharts. This means, you can now write unit tests for your C statecharts in SCTUnit, execute them, and also generate GTests, for execution on a build server, for example.

In SCTUnit you can easily mock the environment your state machine is interacting with by raising events or mocking operation results and then verify corresponding state changes or outgoing events. When writing SCTUnit tests for your C statechart you can access all C elements (variables, operations, datastructures) that are also made accessible in your C statechart by the imported header files.

We have added an SCTUnit test suite to our coffee machine example which you can find in our example wizard. Executing the test suite will also reveal our coverage view showing you which states and transitions have been covered by your tests.

Miscellaneous

Apart from these new features we also worked on many smaller improvements, bug fixes and better performance:

Usability:

Bugfixes:

Performance / Stabilization:

YAKINDU Statechart Tools 3.3.0 (Mar 26, 2018)

In this release our team closed 126 issues in total. Here are the new and noteworthy changes:

Statechart image generator (Standard and Professional Edition):

The statechart image generator renders a statechart and all its subdiagrams, if any, as image files. The generator supports several pixel-based and vector-based image formats. It is configured via a generator model, just like all the other YAKINDU Statechart Tools generators:

GeneratorModel for create::images {

  statechart CoffeeMachine {

      feature Outlet {
          targetProject = "coffeemachine"
          targetFolder = "images"
      }

      feature Renderer {
          format = "svg"
      }
  }
}

Each time the underlying CoffeeMachine statechart is changed, this will create SVG images of the statechart in the folder “images” in project “coffeemachine”.

SCov - Test Coverage Tracing for SCTUnit (Professional Edition)

SCov is the new model coverage feature and part of YAKINDU Statechart Tools Professional Edititon. When a SCTUnit test is executed, SCov will automatically trace all model elements that are executed during a test run. A model element that is fully executed is colored in green, elements that are not executed are colored in red and partly executed model elements are colored in yellow.

The first version supports state activation and transition coverage. Coverage of state local reactions is currently not supported. The upcoming version will also take local reactions into account.

MISRA Short Identifiers (Professional Edition)

The C Domain now offers a further annotation: @ShortCIdentifiers helps you to keep the generated code compliant to rules which require C identifiers not to be longer than 31 characters. To achieve this, instead of shortening names which are part of a statechart’s API, YAKINDU Statechart Tools gives feedback about the names that will be generated and warns if any user input results in C Code that is non-compliant with the 31 character rule. This puts the user in charge of the naming scheme and keeps the resulting C identifiers predictable.

Miscellaneous

YAKINDU Statechart Tools 3.2.0 (Jan 11, 2018)

For this release, the YAKINDU Statechart Tools team fixed 66 Standard Edition and 28 Professional Edition issues. Apart from several bug fixes, we added some great new features:

We also changed the license management for this release. After 30 days of trial you need a valid license file for non-commercial use now. YAKINDU Statechart Tools still is and always be free of charge for non-commercial and academic use. You can apply for a non commercial license here:

https://info.itemis.com/yakindu/statecharts/non-commercial/order/

Pinned diagram editor

By default, a statechart’s definition section is positioned at the left-hand side of the canvas, and it is part of the diagram. Now the definition section comes with an option to pin it to the left-hand side of the view. In order to pin the definition section, you simply click on the small decorator icon in the upper-left corner of the area. This feature has to be enabled first via Window / Preferences / YAKINDU Statechart Tools / Diagram Appearance / Enable pinning of definition section.

New Simulation view

We completely reworked the Simulation view to ease working with parallel simulation sessions. The Simulation view now provides a drop-down box that lists all running sessions. Resume, Pause, Stop and Single step actions can be accessed directly from the view. Furthermore, the current simulation time is now shown. This is especially useful when working with time triggers.

Built-in variables for the generator model

With the October release 3.1.0 we introduced properties and expressions for the generator model . We extended this feature in the current version with a set of meaningful built-in properties that can be used within expressions:

These properties can be used within generator model expressions, for example, to add timestamp, user, and version to the license header in the generated code.

feature LicenseHeader {
    licenseText = "Generated on " + TIMESTAMP + " with YAKINDU Statechart Tools " + SCTVERSION
}

This feature produces the following output:

/* Generated on 11.12.2017 17:08:14 with YAKINDU Statechart Tools 3.2.0 */

C++ Domain (beta)

This release contains the first version of the deep C++ integration feature. It is now possible to import C++ headers and use C++-specific language concepts directly from within a statechart model. Detailed documentation and examples will follow soon.

Miscellaneous improvements and bug fixes

YAKINDU Statechart Tools 3.1.0 (Oct 4, 2017)

This release comes with several bug fixes and the following main features:

Using properties and expressions in generator models

An generator model may assign values to properties and later use these properties in expressions. The following sample generator model uses the var keyword to declare the properties projectName, version, isBeta, and generateTimerServce with their respective types and default values. 

GeneratorModel for create::java {
    
    //Variables can be overridden from command line interface:
    
    var projectName : string = "light_switch_series"
    var version : string = "1.0"
    var isBeta : boolean = true
    var generateTimerServce : boolean = true

    statechart myStateAutomaton {
    
        feature Outlet {
            targetProject = projectName
            targetFolder = "src-gen/" + version + (isBeta ? "beta" : "")
            libraryTargetFolder = "src"
        }
        
        feature GeneralFeatures {
            TimerService = generateTimerServce
        }
    }
}

The model then uses these values in feature clauses by referring to the properties: The values assigned to properties are default values only and can be overridden from the headless code generator like this: 

scc -m myGenmodel.sct -v version=2.0;isBeta=false

The name/value pairs specified by the -v option would override the corresponding default values of the properties in the generator model.This is a very flexible way to tailor the code generator within a headless build.

Read more about this feature in our user guide .

Named parameter calls

Now you can can use named parameters when calling an operation. Consider the following operation declaration:

operation myOperation(xValue : int, yValue : int) : void

This can be called with name parameters like this:

myOperation(xValue = 27, yValue = 42)

Named parameters make their order irrelevant. The following call is semantically equivalent to the one above:

myOperation(yValue = 42, xValue = 27)

While an operation call with named parameters is longer than the equivalent call with positional parameters, named parameters are a great means for self-documenting code (especially if the parameter names are more telling than in the example above).

Option to skip generation of library files

The Outlet feature now has an option to skip the generation of library files. This is useful to prevent the generation of a new library file when an existing one should be used: 

feature Outlet {
    targetProject = projectName
    targetFolder = "src-gen/"
    libraryTargetFolder = "src"
    skipLibraryFiles = headless ? true : false
}

skipLibraryFiles (Boolean, optional): If you wish to exclude the static files from the code generation, i.e. those that are put into the libraryTargetFolder, you can set this value to true. If the value is false or not specified at all, the files are generated as usual. Currently supported for the Java, C and C++ generators.

Miscellaneous improvements and bug fixes

Usability improvements:

Code generation improvements:

Bug fixes:

YAKINDU Statechart Tools 3.0.0 (Jul 18, 2017)

This release is the first major release introducing the YAKINDU Statechart Tools Standard and Professional Editions.

In the last years, YAKINDU Statechart Tools has become more and more popular. This is shown by an ever increasing number of users who use the tool for both commercial and non-commercial purposes, e.g. in academic research. This goes hand in hand with increasing demand for new features and professional support.

In addition to this continuous growth, we also want to ensure sustainable support for the future. So the Standard Edition complements the Professional Edition and we believe that both editions better address our users demand for statechart modeling and development solutions. Both editions are intended for commercial use. For academic and non-commercial use free licenses are available.

The Standard Edition comes with:

The Professional Edition is built on top of the Standard Edition. Thus, all the new features available in the Standard Edition, like our testing framework SCTUnit , are also available in the Professional Edition. In addition to that, the Professional Edition provides a tight integration of statecharts with C code as well as the possibility to use breakpoints and snapshots for debugging your state machine.

The Professional Edition and comes with the following new features and improvements:

System Header Imports

Besides fixing several smaller issues, we took our time in reworking some internals of the deep C integration, especially when it comes to handling header imports. The most notable difference for the user is the possibility to include systems headers in your statechart model.

As you may have noticed the import syntax slightly changed. The preferred way now is to use a string literal to import a header file. However, the old syntax is still supported, but deprecated.

Very Large Header File Support

YAKINDU Statechart Tools are used in many different application domains with different project sizes. Especially in the automotive domain, when dealing with large AUTOSAR models, it is not uncommon to have thousands of source files with sizes up to several MBs with hundreds of thousand of declarations. In order to provide a very good user experience while editing statecharts and also for the code generators, we reworked our indexing infrastructure which is now remarkably faster while using less memory.

SCTUnit - The Testing Framework for State Machines

With this release, we introduce a beta version of our testing framework SCTUnit. SCTUnit allows test-driven development of CREATE Statechart Models. These tests can be executed directly within your IDE to check if the model behaves as expected. It also generates unit tests for Java, C and C++.

Features that can be used in SCTUnit are:

For more information, see our online documentation .

Statechart Execution Semantics

Users now specify the concrete variant of execution semantics in the statechart itself. In previous versions you specified cycle based or event driven semantics using run configurations. Now this is specified using so called annotations. Annotations are also used to specify if the execution order in a hierarchical statechart chart should be parents-first or child-first. For more information, see our online documentation .

Filter for Generator Models

In some cases it might be inconvenient to execute all generator models during a project build, especially if you have different generator models for different use-cases, for example, headless execution. To provide a more fine-grained control of which ones should be executed, it is now possible to exclude particular generator models or entire folders from the automatic build execution in the project’s properties.

Deep C Integration Improvements

Usability Improvements

Code Generation Improvements

Bug Fixes