Revision History

V2.17.0 - 22.04.2024


  • With the new FrequencyCounter measurement, the Time Tagger becomes a full feature Omega-type frequency counter.

  • The new PulsePerSecondMonitor meausrement allows to monitor the synchronicity of different PPS sources.

  • The support of variable integration time per bin in HistogramLogBins provides the accurate g(2) normalization with immediate start and gated inputs.

  • Improve the performance of the Synchronizer to reach the full 80 MTags/s per device.


  • New virtual channel Combinations for exclusive coincidences.

  • Adds support for the Python Stable ABI to support Python 3.12 and likely many more further releases.

  • Adds support for the MinGW C++ ABI for the MINGW32 and UCRT64 environment.

Time Tagger Ultra and Time Tagger X

  • Significantly reduced on-device latency noticeable both over USB and FPGA link.

  • Support for high priority input channels, which will still be transmitted while in overflow domain.

  • The timestamps of rising and falling events can be averaged on hardware for a higher precision of events.

  • Enhanced version of the deadtime filter, which can be configured with any dead time in picosecond precision.

Time Tagger X

  • Full support for the High-Resolution mode on the Time Tagger X with a timing jitter of 1.5 ps RMS per channel.

  • Support for the QSFP+ FPGA link with a data rate of 1200M Tags/s.

  • Support for the readout of more device sensors on the hardware.

  • The self verification of the hardware input stage of the built-in test signal is reverted on the Time Tagger X.

  • All input ports stay at the high-impedance mode before their first usage and after freeTimeTagger().

  • Changes the default hysteresis from 1mV to 20mV.

Time Tagger Ultra

  • Adds support for Time Tagger Ultra with hardware revision 1.8.

  • The improved auto-calibration for periodic signals and its error handling is backported from the Time Tagger X to the Time Tagger Ultra.

  • Improves the USB performance for many aligned inputs.

Time Tagger Lab features and enhancements

  • Improved and more informative landing page layout.

  • Existing measurements can now be cloned easily (by right clicking).

  • The live countrate is now visible in the detailed device view.

  • Application window positions and the measurement list order are now saved to workspace.

  • A notification appears when the measurement dead time is automatically adjusted to a multiple of the Time Tagger clock.

  • New startup command line options –select-device and –start-measurement.

  • Maximum file size for the FileWriter measurement is now shown in megabytes.

  • “Force high impedance” option for Time Tagger X start-up without impedance switch.

  • Many smaller UI improvements and fixes.

Time Tagger Lab bug fixes

  • Fixed various crashes related to device license checks, sending feedback and exporting large data sets to file.

  • Fixed occasional misaligned axis ticks and missing axis ticks when zooming in.

  • Fixed limited application visibility for high sreen scaling settings.

  • Fixed occasionally missing chart cursor values.

  • Changed logarithmic axis labels from E^ to 10^.

V2.16.2 - 28.06.2023

Time Tagger hardware support

  • Adds support for Time Tagger 20 with hardware revision 2.5.

  • Adds support for Time Tagger X with hardware revision 1.2.

Time Tagger bug fix

  • Fixes Counter showing wrong values when the same channel is used multiple times, now throwing an exception on creating.

  • Fixes FileReader in Matlab not loading the .NET Assembly in its constructor. All measurement classes now load the assembly.

Time Tagger Lab

  • Fixes non-visible numbers for cursor values.

  • Moved legend of Counter time trace to the top left.

  • Higher precision formatting values when necessary.

V2.16.0 - 05.06.2023


  • Time Tagger Lab: Virtual Antibunching and Fluorescence lifetime setups.

Time Tagger Lab features and enhancements

  • Antibunching and Fluorescence lifetime setups and corresponding simulation measurements. The detector signals are fully simulated for those measurements and no physical detectors are needed.

  • Option to suppress counts for dt=0 with autocorrelation measurements.

  • Notification that software updates are available.

  • Improved crash and error reporting.

  • Improved ticks and labels of logarithmic plots.

Time Tagger Lab bug fixes

  • Fixed various crashes related to exporting data, opening a message box, and creating log files.

  • Fixed Histogram 2D export.

  • Fixed auto-restarting with no-plot measurements on configuration change.

  • Missing log-y labels and ticks are added to chart display.


  • Adds support for Python 3.11.

  • The built-in test signal verifies the hardware input stage on Time Tagger X starting from hardware revision 1.1.

Bug fixes

  • Fixes fan information of getSensorData() on the Time Tagger Ultra.

  • Fixes the support for Time Tagger Ultra devices with the serials starting with 17.

  • Fixes GatedChannel, FrequencyMultiplier and TriggerOnCountrate to switch to the initial state on clear() and startFor().

  • Fixes autoCalibration() to clear the old calibration data.

  • Fixes the error handling on Linux if parts of the Python wrapper are missing.

  • Fixes a one bit out of bounds memory access on verifying the hardware license.

  • Fixes the jagged array handling of the Matlab Wrapper for Coincidences.

V2.15.0 - 06.03.2023


  • Rework of the Matlab wrapper, now reflecting the full functionality of the Time Tagger API.

Matlab wrapper

  • Supports class inheritance, new TT classes are closer to their C++, and Python counterparts.

  • Supports creation of TimeTagger objects via TimeTagger.createTimeTagger().

  • Supports native Matlab enums.

  • Supports jagged arrays via conversion from/into Matlab cells.

Behavior change

  • Disallow an event divider value of 0. Please use 1 instead.

  • Matlab: Removed Matlab app designer examples.

Other Changes

  • Updated Opal Kelly Frontpanel library to 5.2.12.

Bug fixes

  • Python: Fix return type annotation for createTimeTagger().

  • Fixes certain deadlock issues in Matlab caused by asynchronous functions.

  • Fixes the overflow tracking with a USB error while in overflow.

  • Fixes handling of tags with respect to <-> missed events at the timestamp of an OverflowBegin error.

  • Counter: Fixes a transpose issue of the NaN generation in CounterData.getDataNormalized().

  • FrequencyStability: Fixes an integer overflow in the MDEV / TDEV calculation.

  • Fixed issue with LicenseRequestGenerator.exe not working on some systems.

Time Tagger Lab features and enhancements

  • Device LEDs can be switched on and off (not Time Tagger 20).

  • Improved setting of the reference software clock for signals with an event divider greater than 1.

  • Time Tagger 20 Edu is supported.

Time Tagger Lab bug fixes

  • Fix the crash when capturing high-resolution counter-time traces.

  • Fix the crash when the USB connection to the device is unstable.

  • Fix the crash when exporting large Scope measurement data.

  • Fix the crash when exporting a plot to a PNG file.

  • Fix the crash when measurements require too much memory on initialization.

  • User interface issues with small screens are solved.

V2.14.0 - 23.12.2022

Time Tagger X

  • Adds support for Time Tagger X with hardware revision 1.1.

  • Adds support for Synchronizer with Time Tagger X and also mixed setups with Time Tagger Ultras.

  • Provides preliminary Ethernet support on the SFP+.

  • Improves the auto-calibration for periodic signals.

  • Better CPU performance for aligned tags.

  • Improves the channel LED blinking for 1pps signals.

  • Shows calibration errors on the channel LED in red.

  • Fixes a random skew jump of 1333 ps per input channel on USB errors.

  • Fixes the channel LED indication for falling events.

Bug fix

  • Fix Power LED turning off after calling freeTimeTagger() on the Time Tagger Ultra.

V2.13.2 - 22.11.2022


V2.12.4 - 09.11.2022


  • Adds support for Time Tagger Ultra with hardware revision 1.7.

Bug fix

V2.12.2 - 04.10.2022

Bug fixes

Various improvements

V2.12.0 - 01.09.2022


  • Add support for our new high precision measurement device, the Time Tagger X, with a typical timing resolution of 2.0 picoseconds.



  • Improve the performance of the Synchronizer. Two Time Tagger Ultras now can achieve a total data rate of over 100 Mtags per second.

  • Add support for the new Ubuntu Long Term Support release 22.04 Jammy Jellyfish.

Behavior change

  • All provided strings to the C++ API must be encoded as UTF-8, returning strings are also UTF-8 encoded.

  • Rename getLicenseInfo() to TimeTagger.getDeviceLicense(). It returns a JSON formatted string for easier processing.

  • Drop support for obsolete Python versions 2.7 and 3.5 and for the obsolete Linux distributions CentOS 7 and Ubuntu 16.04.


  • Jitter verification requests the specified jitter values directly from the Time Tagger backend.

  • FLIM example is now available for Matlab

Various Fixes and Improvements

  • Fix Unicode characters in all filenames of FileWriter and FileReader.

  • Fix CoincidenceFactory for Matlab and Labview.

  • Fix the Flim measurement for Matlab.

  • Fix the crash on a failing license download within the initialization of the Network Time Tagger.

  • Prefer a host-locked license over a user-locked license in the Virtual Time Tagger. This reduces the chance of a false-positive anti-virus warning.

  • Improve the rounding behavior of TimeTagger.getTriggerLevel().

  • Update of the USB driver for various fixes.

V2.11.0 - 22.04.2022


Time Tagger Network

  • New Protocol version 3.1 with a new set of features. Backward compatible with 3.0.

  • Improved messages for connection loss and disconnection. Additionally, messages for connecting to new and old versions of TTN will be presented.

  • Fixed issue related to implicit call of sync() on measurement creation in AccessMode.Listen mode.

  • Server and network information has been added to getConfiguration().

  • Fixed crashes when streaming over 250 channels.

  • Various race conditions and possible freezes have been fixed.

  • Faster initialization of measurements with many channels.

  • Fixed error handling on disconnection.

  • Reduced connection timeout to 10 seconds.

  • Fixed an issue where channels used by a client remained registered after a disconnect.

  • TimeTagger.setTimeTaggerNetworkStreamCompression() can be utilized to double the maximum transfer rate in a very slow network environment (<= 100 Mbit/s).

Time Tagger Virtual

  • The TimeTaggerVirtual will now wait for a test signal channel to be registered before starting to stream it (behavior identical to a hardware Time Tagger).


  • Optional constructor argument initial of type GatedChannelInitial to initialize the gate optionally in an open state.

  • Changed behavior if input_channel equals gate_start_channel or gate_stop_channel to allow for operation similar to the ConditionalFilter.


  • Fixed getTraceFrequency(); now it returns the relative frequency error instead of the relative period error.

  • Traces are no longer truncated to the length of the maximum steps.

  • Corrected behavior if stopped and restarted without clearing.

Other measurement classes


  • Improved error messages.

  • Fixed USB errors occurring under very high data rates.


  • Added Visual Basic .NET example

Various Fixes

  • Fixed crash on createTimeTagger() during a USB error.

  • Fixed an issue where startFor() could run further than the specified time on HistogramLogBins and FileWriter.

  • WebApp: Fixed argument handling on Linux.

  • Matlab: Supports now Resolution for HighRes.

  • Matlab: Verifies that the version of the installed backend matches the wrapper version.

V2.10.6 - 16.03.2022


  • Adds support for Time Tagger Ultra with hardware revision 1.6b.

V2.10.4 - 23.02.2022


V2.10.2 - 31.12.2021


  • Added support for Python 3.10.

Fixes for issues since v2.10.0

V2.10.0 - 22.12.2021


  • Time Tagger Network: All Time Tagger devices and the acquired data can be accessed via the network from multiple clients or locally across the different programming languages. The clients can use all TimeTagger measurement classes and may optionally control the settings of the physical Time Tagger.

  • A new frequency stability toolbox: It offers on-the-fly evaluation of periodic signals by calculating several analysis metrics, including, for example, the Allan deviation (ADEV) and time deviation (TDEV).

  • Software Clock: The new recommended method for using an external clock on the Time Tagger Ultra. The time tag stream is rescaled on the software side with respect to the connected clock. It allows for a broad input frequency range and also calculates phase error estimators. In addition, the input jitter of the clock channel will be averaged out, resulting in a lower jitter for measurements including the clock channel directly.


  • Counter: New Counter.getDataObject() returning data as an object of CounterData and allowing for continuous chunkwise data acquisition. This object contains the Counter data, timing information and overflow flags.

  • New HistogramND measurement, which is a multidimensional generalization of the older Histogram2D.

  • New Sampler measurement class for a triggered sampling of the current state of other channels.

  • Measurement and virtual channel settings can now be requested with getConfiguration() method. The settings of all measurements are also available in the return value of getConfiguration() method.


  • A Time Tagger Network server can be activated in the settings.

  • Includes the Software Clock feature.

  • Adds Event Divider settings.

  • Shows specified RMS jitter for each channel in HighRes mode.

  • It is now possible to specify the integration time in a single-shot or cyclic mode (internally uses startFor()) for all available measurement classes.


Behavior change

  • TimeTagStream now always requires a list of channels.

  • CustomMeasurement in Python: with self.mutex replaces self.lock and self.unlock.

  • A Synchronizer with only one Time Tagger will use the timestamps of the Synchronizer but the channel identifiers of the single device itself.

  • No messages on the INFO level will be shown in Matlab to avoid running into deadlocks.

  • std::invalid_argument exceptions are now wrapped as ValueError in Python.


  • New Python example to measure the maximum transfer rate and the jitter.

  • New Python example to show coincidence counting applications.

  • New example to show the use of the software clock and measure the frequency stability of the test signal in Python, Matlab and LabVIEW.

  • Update the Counter example in Python and Matlab to show the use of the new CounterData.


  • Skips an unlikely blocking freeTimeTagger() call for up to 10 seconds.

  • Fixes the 64-bit signed integer overflow after 106 days on Linux.

  • Stops playing the last sound of setSoundFrequency() after freeTimeTagger().

  • Fixes the timing of TimeTagStreamBuffer.tGetData in the last block of FileReader.

  • Adds support for TTU HW revision 1.6 and TT20 Value.

  • Fixes the empty configuration and channel list in FileReader before fetching the first time tag.

  • Fixes a race condition on the Time Tagger Ultra, which may yield one invalid time tag after USB connection errors.

  • Fixes a crash on using with CustomMeasurement() as c in Python.

  • Fixes incorrectly displayed units in the WebApp if measurement settings changed during a measurement.

  • Fixes the behavior of Histogram2D if start_channel matches a stop channel.

  • Fixes the behavior of Countrate with startFor if it ends within an overflow interval.

V2.9.0 - 07.06.2021


  • Reduced communication latency of all Time Taggers.

  • Reduced Time Tagger 20 crosstalk on channel 1 and 2.

  • Improved USB connection stability for Time Tagger 20.

  • Optional collection and reporting of pseudonymous usage statistics. Improvement program.

  • Please use at least v2.9.0 for devices shipped from 2021 on.



  • Added TimeTagger.setHardwareBufferSize() for the Time Tagger 20.

  • Added an example and tutorial on how to work with a remote Time Tagger using Python and the Pyro5 package.

  • License upgrades can be flashed now for the Time Tagger 20 via the web application.

Bug fixes

V2.8.4 - 04.05.2021

  • Fixed the initialization for a Virtual Time Tagger in the Web Application

V2.8.2 - 26.04.2021

  • Fixed non appearing option to initialize in HighRes mode after upgrading/flashing the device in the Web Application.

V2.8.0 - 29.03.2021


  • High-resolution options for the Time Tagger Ultra series with a timing jitter of down to 4 ps RMS per channel.

  • Hardware input delay on the Time Tagger Ultra series with picoseconds accuracy before the conditional filter.

  • Reduced CPU load for Time Tagger Ultra.


The release is fully compatible with all Time Tagger 20 devices. It is compatible with all Time Tagger Ultra devices shipped from March 2021 and all earlier Time Tagger Ultra devices with 8 or less channels without HighRes option. If you received Time Tagger Ultra before March 2021 and it has more than 8 channels or HighRes, it is not compatible with the release. Please contact support to get a free device exchange to be fully compatible again.

New Time Tagger Ultra features

  • Reduced crosstalk and thermal drift on all channels.

  • The Time Tagger hardware sound module can be activated and set via TimeTagger.setSoundFrequency(). It can be used, e.g., for optical alignment purposes (count rate -> frequency).



  • Added a TriggerOnCountrate virtual channel that generates events when a count rate crosses the given threshold value.

  • Added support for Python 3.9.

  • waitUntilFinished() and sync have an optional timeout parameter.


  • Mathematica: Added example for FileWriter and TimeTaggerVirtual().

  • LabVIEW: Fixed broken example (#14) and added it to the LabVIEW project.

  • C++: Added an example for Custom Virtual Channel.

Bug fixes

V2.7.6 - 26.04.2021

  • Fixed RuntimeError “Got the USB error ‘UnsupportedFeature’” when calling createTimeTagger()

V2.7.4 - 19.04.2021

  • Fixed a bug for old Time Tagger Ultras, where the Web Application could not apply the license upgrade.

V2.7.2 - 22.12.2020


  • Reworked Flim implementation. Versatile high-level functionality with Flim and low-level CPU- and memory- efficient access via FlimBase and callbacks.

  • Highly improved TimeTaggerVirtual performance taking use of multithreading.

  • Support for direct time tag stream access via Custom Measurements in C# and Python - see examples in the installation folder.


  • Added AnyCPU targeted .NET Assembly for C# wrappers. Available in GAC_MSIL and the installation folder.

  • More detailed error handling and human-readable error messages.

  • Added Conditional Filter for TimeTaggerVirtual.

  • Removed Intel’s libmmd.dll library dependency.

  • All measurements have the new common method waitUntilFinished(), which can be used with startFor().

  • Warnings are printed with time information.

  • Cleanup of the C++ measurements’ header file.

  • Remote license upgrades can be performed via the web application.

  • Reworked Python and C# examples.


API changes

  • The old FLIM class is replaced by a new implementation: Flim. In case you need the old implementation, there is a 1 to 1 replacement, see here.

  • All methods and measurements now throw exceptions instead of warning on wrong arguments like invalid channels or out-of-range parameters.

  • Automatically call freeTimeTagger on del/clear/Dispose in Python/Matlab/LabVIEW/C# .

  • Removed the freeAllTimeTagger method.

  • Deprecate the multiple use of createTimeTagger() for one physical device. Pass on the timetagger object instead.

  • _Log is renamed to LogBase.

  • Our libraries are compiled with VS 2019 now, so at least version 142 of the VC runtime is required in the final application.

V2.7.0 - 01.10.2020


  • New measurements are automatically synchronized to the hardware. All data analyzed is guaranteed to be temporal later than the measurement’s initialization, start, or clear. Data coming from the internal buffer, which was acquired before the measurement was initialized, started, or cleared, will not be analyzed. Before this release, the .sync() method was required for these tasks.

Fixes and improvements

  • Added a Matlab example for SynchronizedMeasurements.

  • Fixed a bug in Matlab, creating synced measurements via SynchronizedMeasruements and .getTagger().

  • The last datapoint from a scope measurement is not marked as invalid any more.

V2.6.10 - 07.09.2020

Fixes and improvements

  • Fixes input delay, deadtime and test signal generator for the TimeTaggerVirtual.

  • Fixes getInvertedChannel with the Swabian Synchronizer and with Time Tagger Ultra 8 devices with the old channel numbering schema.

  • x axis is zoomable with Scope measurement.

  • Better error handling for non-existent files with TimeTaggerVirtual and FileReader.


  • Changed the constants CoincidenceTimestamp_ to a Python enum (e.g., CoincidenceTimestamp_First is now CoincidenceTimestamp.First).


  • Enum for timestamp argument for Coincidence(s) is available via TTCoincidenceTimestamp.


  • Fix for slow Linux device opening.

V2.6.8 - 21.08.2020


  • Support for the Time Tagger Value edition. This is an upgradeable and cost-efficient version of the Time Tagger Ultra for applications with moderate timing precision requirements.


  • Added Histogram2D to the measurement list.

  • Improved performance and responsiveness for large datasets.

  • 32-bit version of the Web Application works again.

  • Fixed a bug that data of stopped measurements could not be saved.

  • Fixed a bug that settings saved had the file extension .json instead of .ttconf ending.

  • Fixed a bug when using falling edges for Time Tagger starting with channel 0.


  • Fixed a bug that some named arguments could not be used anymore.



  • Improved performance of the FileWriter, exceeding 100 M tags/s on high-end CPUs.

  • Improved binning performance of all histogram measurements: Correlation, FLIM, Histogram, StartStop, TimeDifferences, TimeDifferencesND.

  • Fixes a deadlock in the virtual Time Tagger if a measurement accesses some public methods of the Time Tagger.

V2.6.6 - 10.07.2020


  • Swabian Synchronizer support. The Synchronizer hardware can combine 8 Time Tagger Ultras with up to 144 channels. The combined Time Tagger can be interfaced the very same as it would be only one device.

  • Support for custom measurements in Python. Please see the provided programming example in the installation folder for further details.


  • Support for the Synchronizer

  • Showing error messages from setLogger API in a modal window

  • Load/save settings is now supported for the Time Tagger Virtual

Time Tagger Ultra

  • Hardware revision 1.1 now with the same performance enhancement of 500 MHz maximum sync rate, 2ns dead time and better phase stability, as introduced before for Hardware revision > 1.1

  • Dropped support for the very first Time Tagger Ultras, an error will be shown on initialization - free exchange program available

  • More intuitive byte order of the bitmask in setLED

  • Small modifications to the hardware channel to channel delay


  • Coincidence and Coincideces have an optional parameter to select which timestamp should be inserted, the last/first completing the coincidence, the average of the event timestamps, or the first of the coincidence list.

  • Fixed .net/Matlab/LabVIEW wrappers for data with empty 2D or 3D arrays

  • Provide a globally registered .NET publisher policy for C#, avoiding the ‘wrong dll version’ message in Labview when updating the Time Tagger software

  • setConditionalFilter throws an exception when invalid arguments are applied

  • Hide the warning on fetching the TimeTaggerVirtual license without an internet connection

  • DelayedChannel supports a negative delay

  • Performance enhancements in StartStop

V2.6.4 - 27.05.2020


  • Option to enable logarithmic y-axis scaling for Counter, Histogram, HistogramLogBins and Correlation

  • Redesign “Create measurement” dialog with links to the online documentation

  • Fixed flickering when switching between plots

  • Fixed plotting wrong data range when changing the number of data points

  • Added the basic functionality of the TimeTaggerVirtual (test signal only)

New features and improvements

  • Added the test signal to TimeTaggerVirtual

  • Support for Ubuntu 20.04 and CentOS 8

  • LabVIEW example for FileWriter and FileReader

  • Improved Matlab API for VirtualTimeTagger, adding optional parameters

  • Make the data transfer size configurable by .setStreamBlockSize

  • Performance improvements for HistogramLogBins

  • Slightly improved timing jitter at large time differences for the Time Tagger 20

  • Time Tagger Application works again with 32 bit operating systems

  • Connection errors are shown in the Matlab console or can be handled with the new logger functionality

  • Added custom logger examples for Matlab/Python/C#


  • Updated the USB library

  • Stop measurements when freeTimeTagger is called (e.g. closes files on dump, isRunning now returns false)

  • Reduced polling rate (0.1s) for USB reconnections

API changes

  • Added .setLogger() to attach a callback function for custom info/error logging

  • Rename of enumeration ErrorLevel to LogLevel

  • Rename of log level constants and with new corresponding integer values

V2.6.2 - 10.03.2020


  • TimeTaggerVirtual, FileWriter, and FileReader have reached a stable state

  • Improved Linux support (documentation, compiling custom Python wrappers)

New features

  • Added setInputDelay, setDeadtime, getOverflows, and more to the TimeTaggerVirtual

  • Add an optional parameter in setConditionalFilter for disabling the hardware delay compensation

  • Infinite dumping in Dump for negative max_count

  • Create a freeAllTimeTagger() method, which is called by Python atexit

  • Reimplement SynchronizedMeasurements as a proxy tagger object, which auto registers new measurements without starting them

  • The new SynchronizedMeasurements.isRunning() method returns if any measurement is still running

  • Python: Distribute the generated C++ wrapper source for supporting future Python revisions

  • C++: New IteratorBase.getLock method returning a std::unique_lock

  • C++: Improved exception handling for custom measurements: exceptions now stop the measurement, runSynchronized forwards exceptions to the caller

API changes

  • TimeTagger.getVersion return value is changed to a string

  • C++: Use 64 bit integers for the dimensions in the array_out helpers

  • C++: Rename the base class for custom measurements from _Iterator to IteratorBase

  • C++: Constructors of custom measurements shall call finishInitialization instead of IteratorBase.start

  • Python 2.7: Update the numpy C headers to 1.16.1

Examples and documentation

  • Improved Histogram2D example

  • Clarify setInputDelay vs DelayedChannel

Bug fixes

  • Relax the voltage supply check in the Time Tagger Ultra hardware revision 1.4

  • Use a 1 MB buffer for Dump, FileWriter, and FileReader to achieve full speed especially on network devices

  • Fix getTimeTaggerModel on an active device

  • Fix deadlock within sync() while the device is disconnected

  • Provide the documentation on Linux

  • Several fixes and improvements for the FileWriter and TimeTaggerVirtual


  • Improved default names for measurements

  • Not relying on data stored within the browser any more

  • Disabling mouse scrolling within numeric inputs

  • Various buxfixes

V2.6.0 - 23.12.2019


  • FileWriter: New space-efficient file writer for storing time tag stream on a disk. The file size is reduced by a factor of 4 to 8. Replaces the Dump function.

  • Virtual Time Tagger allows to replay previously dumped events back into the Time Tagger software engine.

  • Improved behavior in the overflow mode. The hardware now also reports the amount of missed events per input channel and provides the start and the end timestamps of the overflow interval.

  • New tutorial on how to implement the data acquisition for a confocal microscope

  • New measurement Histogram2D for 2-dimensional histogramming with examples

  • Web App: Selectable input units (s/ms/µs/ps) instead of ps only

Known issues

  • FileWriter and FileReader have a low performance on network devices

API changes

  • deprecated TimeTagStreamBuffer.getOverflows() – use .getEventTypes() instead

  • renamed HistogramLogBin.getDataNormalized() to .getDataNormalizedCountsPerPs()

  • removed deprecated TimeTagger.getChannels() - use .getChannelList() instead

  • removed deprecated CHANNEL_INVALID - use CHANNEL_UNUSED instead

  • removed deprecated TimeTagger.setFilter() and TimeTagger.getFilter() - use .setConditionalFilter(), .getConditionalFilter(), and .clearConditionalFilter() instead

  • C++: All custom measurement class constructors must be modified, such that the parameter containing the Time Tagger is of the type TimeTaggerBase. This allows for using the custom measurement within a real Time Tagger object and the Time Tagger Virtual.

  • C++: The struct Tag includes the type of event and the amount of missed events. They have replaced the overflow field.

  • C++/Windows: We additionally distribute binaries for the debug runtime (/MDd)

  • Matlab: is now deprecated, use .freeTimeTagger()

New features

  • Web App: Normalization (counts/s) for the Counter measurement

  • getConfiguration returns the current hardware configuration as a JSON string

  • added g2 normalization for HistogramLogBins with getDataNormalizedG2

  • improved overflow behavior for Countrate due to the missed event counters

  • improved overflow handling for the g2 normalization of Correlation and HistogramLogBin

  • support for Python version 3.8

  • smaller latency on low data rates due to adaptive chunk sizes of <= 20 ms

  • support for the Time Tagger Ultra hardware revision 1.4


  • Matlab: Faster loading of events from disk for now deprecated Dump file format

  • C++: Loading events from disk stored in the new data format

  • Labview: Scope example, .NET version redirection

  • Mathematica: Improved example

  • Python: Added “Stop” button to the countrate figure.

Bug fixes

  • fixed static input delay error with conditional filter enabled since v2.2.4

  • added missing TimeTagger.getTestSignalDivider() method

  • Scope: Fix the output if one channel has had no events

  • resolve overflows after the initialization of the Time Tagger 20

  • fixes an issue with wrongly sorted events on the reconfiguration of input delays

  • always emit an error event on plugging an external clock source

  • fixes an unlikely case when the synchronization of the external clock got lost

  • the new USB driver version fixes some random data abruption

  • TTU1.3: Fix a bug which may select a wrong clock source in the first 21 seconds and wrongly activated ext clock LED

  • Matlab: SynchronizedMeasurements work now in Matlab, too

  • different improvements within the python and C# wrappers

  • LED turns off and not red after freeing a Time Tagger

  • Dump now releases the file handle after the end of the startFor duration

  • Web App: Removed caching issues when up or downgrading the software

V2.4.4 - 29.07.2019

  • reduced crosstalk between nonadjacent channels of the Time Tagger Ultra

  • fixed a bug leading to high crosstalk with V2.4.2 for specific channels

  • fixed a rare clock selection issue on the Time Tagger 20

  • improved and more detailed documentation

  • new method Countrate.getCountsTotal(), which returns the absolute number of events counted

  • new Mathematica quickstart example

  • new Scope example for LabVIEW

  • support of the Time Tagger 20 series with hardware revision 2.3

  • release the Python GIL while in the Time Tagger engine code

  • fixed a bug in ConstantFractionDiscriminator, which could cause that no virtual tags were generated

V2.4.2 - 12.05.2019

  • support of the Time Tagger Ultra series with hardware revision 1.3

  • improve performance of short pulse sequences on the Time Tagger 20 series

  • improve overflow behavior at too high input data rates

  • fix the name of the ‘SynchronizedMeasurements’ measurement class

V2.4.0 - 10.04.2019


  • 32 bit C++ library added

  • C++ and .NET libraries renamed and registered globally


  • virtual constant fraction discriminator channel ‘ConstantFractionDiscriminator’ added

  • ‘TimeDifferenceND’ added for multidimensional time differences measurements

  • faster binning in ‘TimeDifferences’ and ‘Correlation’ measurements

  • improved memory handling for ‘TimeTageStream’

  • improved Python library include

  • fixed ‘.getNormalizedData’ for ‘Correlation’ measurements

  • various minor bug fixes and improvements


  • LabVIEW project for 32 and 64 bit

  • improved LabVIEW examples

Time Tagger Ultra

  • 10 MHz EXT input clock detection enabled

  • internal buffer size can be increased from 40 MTags to 512 MTags with ‘setHardwareBufferSize’

  • reduced crosstalk and timing jitter

  • increased maximum transfer rate to above 65 MTags/s (Intel 5 GHz CPU on 64 bit)

  • various performance improvements

  • reduced deadtime to 2 ns on hardware revision >= 1.2

Time Tagger 20

  • 166.6 MHz EXT input clock detection enabled

Operating systems

  • equivalent support for Windows 32 and 64 bit, Ubuntu 16.04 and 18.04 64 bit, CentOS 7 64 bit

V2.2.4 - 29.01.2019

  • fix the conditional filter with filter and trigger events arriving within one clock cycle

  • fix issue with negative input delays

  • calling .stop() while dumping data stops the dump and closes the file

  • fix device selection on reconnection after transfer errors

  • synchronize tags of falling edges to their rising ones

V2.2.2 - 13.11.2018

  • Removed not required Microsoft prerequisites.

  • 32 bit version available

V2.2.0 - 07.11.2018

General improvements

  • support for devices starting with channel 1 instead of 0

  • under certain circumstances, the crosstalk for the Time Tagger 20 of channel 0-2, 0-3, 1-2, and 1-3 was highly increased, which has been fixed now

  • updated and extended examples for all programming languages (Python, Matlab, C#, C++, LabVIEW)

  • C++ examples for Visual Studio 2017, with debug support

  • documentation for virtual channels

  • Web app included in the 32 bit installer

  • Linux package available for Ubuntu 16.04

  • Support for Python 3.7


  • ‘HistogramLogBin’ allows analyzing incoming tags with logarithmic bin sizes.

  • ‘FrequencyMultiplier’ virtual channel class for upscaling a signal attached to the Time Tagger. This method can be used as an alternative to the ‘Conditonal Filter’.

  • ‘SynchronizedMeasurements’ class available to fully synchronize start(), stop(), clear() of different measurements.

  • Second parameter from ‘setConditionalFilter’ changed from ‘filter’ to ‘filtered’.

Web application

  • full ‘setConditionalFilter’ functionality available from the backend within the Web application

V2.1.6 - 17.05.2018

fixed an error with getBinWidths from CountBetweenMarkers returning wrong values

V2.1.4 - 21.03.2018

fixed bin equilibration error appearing since V2.1.0

V2.1.2 - 14.03.2018

fixed issue installing the Matlab toolbox

V2.1.0 - 06.03.2018

Time Tagger Ultra

  • efficient buffering of up to 60 MTags within the device to avoid overflows

V2.0.4 - 01.02.2018

Bug fixes

  • Closing the web application server window works properly now

V2.0.2 - 17.01.2018


  • Matlab GUI example added

  • Matlab dump/load example added

Bug fixes

  • dump class writing tags multiple times when the optional channel parameter is used

  • Counter and Countrate skip the time in between a .stop() and a .start() call

  • The Counter class now handles overflows properly. As soon as an overflow occurs the lost data junk is skipped and the Counter resumes with the new tags arriving with no gap on the time axis.

V2.0.0 - 14.12.2017

Release of the Time Tagger Ultra


The input delays might be shifted (up to a few hundred ps) compared to older driver versions.

Documentation changes

  • new section ‘In Depth Guides’ explaining the hardware event filter


  • fixed a bug setting the input values to 0 when typing in a new value

  • new server launcher screen which stops the server reliably when the application is closed

V1.0.20 - 24.10.2017

Virtual Channels

  • DelayedChannel clones and optionally delays a stream of time tags from an input channel

  • GatedChannel clones an input stream, which is gated via a start and stop channel (e.g. rising and falling edge of another physical channel)


  • startFor(duration) method implemented for all measurements to acquire data for a predefined duration

  • getCaptureDuration() available for all measurements to return the current capture duration

  • getDataNormalized() available for Correlation

  • setEventDivider(channel, divider) also transmits every nth event (divider) on channel defined


  • label for 0 on the x-axis is now 0 instead of a tiny value

C++ API:

  • internal change so that clear_impl() and next_impl() must be overwritten instead of clear() and next()

Other bug fixes/improvements

  • improved documentation and examples

V1.0.6 - 16.03.2017

Web application (GUI)

  • load/save settings available for the Time Tagger and the measurements

  • correct x-axis scaling

  • input channels can be labeled

  • save data as tab separated output file (for Matlab, Excel, … import)

  • fixed: saving measurement data now works reliably

  • fixed: ‘Initialize’ button of measurements works now with tablets and phones


  • direct time stream access possible with new class TimeTagStream (before the stream could be only dumped with Dump)

  • Python 3.6 support

  • better error handling (throwing exceptions) when libraries not found or no Time Tagger attached

  • setTestSignal(…) can be used with a vector of channels instead of a single channel only

  • Dump(…) now with an optional vector of channels to explicitly dump the channels passed

  • CHANNEL_INVALID is deprecated - use CHANNEL_UNUSED instead

  • Coincidences class (multiple Coincidences) can be used now within Matlab/LabVIEW

Documentation changes

  • documentation of every measurement now includes a figure

  • update and include web application in the quickstart section

Other bug fixes/improvements

  • no internal test tags leaking through from the initialization of the Time Tagger

  • Counter class not clearing the data buffer in time when no tags arrive

  • search path for bitfile and libraries in Linux now work as they should

  • installer for 32 bit OS available

V1.0.4 - 24.11.2016

Hardware changes

  • extended event filter to multiple conditions and filter channels

  • improved jitter for channel 0

  • channel delays might be different from the previous version (< 1 ns)

API changes

  • new function setConditionalFilter allows for multiple filter and event channels (replaces setFilter)

  • Scope class implements functionality to use the Time Tagger as a 50 GHz digitizer

  • Coincidences class now can handle multiple coincidence groups which is much faster than multiple instances of Coincidence

  • added examples for C++ and .net

Software changes

  • improved GUI (Web application)

Bug fixes

  • Matlab/LabVIEW is not required to have the Visual Studio Redistributable package installed

V1.0.2 - 28.07.2016

Major changes:

  • LabVIEW support including various example VIs

  • Matlab support including various example scripts

  • .net assembly / class library provided (32 and 64 bit)

  • WebApp graphical user interface to get started without writing a single line of code

  • Improved performance (multicore CPUs are supported)

API changes:

  • reset() function added to reset a Time Tagger device to the startup state

  • getOverflowsAndClear() and clearOverflows() introduced to be able to reset the overflow counter

  • support for python 3.5 (32 and 64 bit) instead of 3.4


initial release supporting python

Channel Number Schema 0 and 1

The Time Taggers delivered before mid 2018 started with channel number 0, which is very convenient for most of the programming languages.

Nevertheless, with the introduction of the Time Tagger Ultra and negative trigger levels, the falling edges became more and more important, and with the old channel schema, it was not intuitive to get the channel number of the falling edge.

This is why we decided to make a profound change, and we switched to the channel schema which starts with channel 1 instead of 0. The falling edges can be accessed via the corresponding negative channel number, which is very intuitive to use.

Time Tagger 20 and Ultra 8

Time Tagger Ultra 18







0 to 7

8 to 15

0 to 17

18 to 35



1 to 8

-1 to -8

1 to 18

-1 to -18


With release V2.2.0, the channel number was detected automatically for the device in use. It was according to the labels on the device. With release V2.17.0, the channel number starts with the number 1 by default for all devices, regardless of the labels on the device.

In case another channel schema is required, please use setTimeTaggerChannelNumberScheme(int scheme) before the first Time Tagger is initialized.

int getInvertedChannel(int channel) was introduced to get the opposite edge of a given channel independent of the channel schema.