As of TEMU 2.2.7, news is maintained here

TEMU 2.2.6 (2021-03-15)

TEMU 2.2.6 has been released.

  • Bug Fixes:
    • Missing CLKDIV register in GRSPW2 model
  • Enhancements:
    • Accept TEMU3 licenses in TEMU2.

TEMU 2.2.5 (2021-01-06)

TEMU 2.2.5 has been released.

  • Bug Fixes:
    • Addresses regression on excessive logging fixed in v2.2.1.

TEMU 2.2.4 (2020-11-20)

TEMU 2.2.4 has been released.

  • Bug Fixes:
    • Fix crash in memory space model when accessing unmapped memory areas.

TEMU 2.2.3 (2020-11-09)

TEMU 2.2.3 has been released.

  • Bug Fixes:
    • Possible crash when fetching instructions from an MMIO device without fetch handler.

TEMU 2.2.2 (2020-10-13)

TEMU 2.2.2 has been released.

  • Bug Fixes:
    • LEON2 timer problem near overflow
    • Expose stickyBits flag in CPU for resume on halt support

TEMU 3 Beta (2020-09-03)

A TEMU 3 prerelease has been released. The release includes a new command interpreter, faster CPU interpreters, and experimental binary translation (off by default).

TEMU 2.2.1 (2020-06-22)

TEMU 2.2.1 has been released.

  • Bug Fixes:
    • Fixes excessive logging in GR1553B model

TEMU 2.2 (2020-06-18)

TEMU 2.2 has been released.

  • Added PowerPC architecture support:
    • Added PPC750 CPU core model
  • Added ARMv7-R architecture support:
    • Added ARMv7-R CPU core model.
    • Added Cortex-R4 based memory controller.
    • Added a sysconfig file for TMS570LC43.
    • Added TMS570 VIM, SCI-LIN and RTI device models
  • Rebased to LLVM 6.0 (internal change)

  • A lot of activity has been on internal cleanup.

  • POTENTIALLY BREAKING API CHANGE: Event API is rewritten, the old one is there and is compatible with the new one, except for the event registration function (which should be replaced with temu_publishOldStyleEvent) which now takes a source object pointer.

    The event publication is with the new API mandatory before posting an event (previously, it was technically only needed for checkpointing support).

    Users should move to the new style events as soon as possible. These events are preallocated when models are allocated and a lot faster than the old style events.

    The old style event API is marked as deprecated and it will be removed in a later release.

    Allthough, while the old style event API is still there, it has been renamed LegacyEventIface in the code. Thus, when you rebuild your models you must make a decision on either sticking with the deprecated legacy API or moving to the new API.

    New API is based on a function interface, and it is no longer needed to handle the writing of a queue property in a special way to register events. To post an event use the temu_eventPostXXX() functions (where XXX at present is Cycles, Nanos and Seconds).

  • Python API is reorganised. Please update your Python scripts with the new module paths ( insead of

    • will keep the raw wrappers over the C-api.

    • (not including temu.c) will provide a more native and natural Python API when implemented.

  • Command API added. In T-EMU 2.1 and earlier, there was no user exposed API for adding custom commands the only way to do this was an internal C++-API which was/is not exposed to the user. We now provide a C and Python API to create user commands.

    • Additional functions added to temu-c/Support/CommandLine.h

    • Added Python API for creating commands using kwarg syntax. the raw API can be accessed with ‘import temubuiltins’ (at the moment).

  • Replacing GDB Server C++ API with C99 API, old headers have been deleted.

  • ELF Symtab API added. The API supports loading and querying the symbol tables in an ELF file. The symtabs are useful as fallback if DWARF info is not available.

  • DWARF support extended and source level debugging commands added.

  • MIL-STD-1553 support is starting to stabilise, it is still however marked as experimental until it has been properly tested by more third parties implementing bus controller and remote terminal models.

  • SpaceWire models added (GRSPW, GRSPW2, GRSPWROUTER)

  • CAN models added (SimpleCANBus, CAN_OC, GRCAN)

  • Ethernet models added (GRETH, GRETH_GBIT)

CPU Changes

  • The emulator generator support tool has been rewritten and is a lot simpler now. This paves the way for more advanced interpretation methods and binary translation further on in time. CPUs should otherwise remain identical to their function. This is an internal change and does not have an impact on the end user.

API Changes

  • Event API has been redesigned, the old API is still around but there was one breaking change in the event registration function.

  • Command API added that allows the user to insert new command line handlers in both C and Python.

  • GDB C++ API is removed, replaced with plain C-API.

  • Python API has been moved under namespace.

PowerPC Support (2018-11-23)

A beta version of the PowerPC CPU core model is now available in the nigthly builds. The current modelled CPU is based on the PPC750, i.e. 32 bit, without Altivec support.

TEMU Features (2018-03-19)

TEMU nightly builds now contains a number of major new features, which has been targeted for the upcoming 2.2 release:

  • Source level debugging support. The new DWARF support is now exposed to support break point manipulation and source listing. It still lacks data inspection and manipulation support, but the current support is already good enough to inspect control flow at source level without having to start up the GDB server.
  • ARMv7-R support. TEMU now supports ARM in addition to the existing SPARCv8 achitecture.
  • Registers. By adding an API for register definition, important meta information about e.g. register fields can be kept available in the TEMU command line interface. Register registration is used instead of properties when adding registers to a class.
  • Clock model. The clock model can replace processors as a time source and event queue. The purpose of it is to simplify model testing and to support hardware in the loop scenarios where a CPU is replaced with a physical variant.
  • Components. Component support has been added. This enables the hierarchical decomposition of systems, which especially simplifies the creation of systems with e.g. multiple LEON3 systems since individual models for each device no longer need to be created.
  • Additional bus models. TEMU now have support for 1553, CAN and SpaceWire buses, providing fully virtual bus models with easy to use APIs.

Upcomming API Breakage (2016-03-07)

For TEMU 2.2 there will be some API breakage, firstly the count parameter of the temu_addInterface function will be removed. This parameter is not used at present. If you are using the emulator from C++, the parameter has a default argument, so it should not have any significant effect.

The second more fundamental change will be the event system. The current system is being rewamped with support for pre-allocated event structures. This should speed up the event system by removing allocations during event insertion and removal. The old EventIface has been renamed LegacyEventIface (the LegacyEvent interface has been deprecated as well). The new event system is backwards compatible except for how events are published. Thus, calls to the registerEvent method in the interface should be replaced with temu_eventPublishOldStyle(), this call should be made in the model constructor intead of when the queue object is connected.

The main point with this is that the event API is moving away from the interface based variant, to a function based variant.

There will be two options:

  • Switch to the new event system
  • Update connect calls to refer to LegacyEventIface instead of EventIface.

Note that the legacy event interface will be removed completely in release following TEMU 2.2. So it is recommended that you move to the new event system instead.

The advantages are two fold. Firstly the new temu_Object class that all internal classes must inherit from now has a reference to its queue object (which can be connected in the CLI with the connect-timesource function). You therefore no longer need to add a EventIface reference property to your model. Secondly, the new function based interface allow the posting of events using one out of three time bases (cycles, nanoseconds or seconds).

The new API is less confusing, and more easy to use. In addition, it should result in signficant performance advantages for high frequency and high volume event usage.

TEMU 2.1.0 Released (2015-11-13)

TEMU 2.1 has now been released. For more information, see the release notes and the download page.