Coherent GT

Changelog for Coherent GT

Version – released 25 Jul 2019

Enhancement Updated Renoir backend to be compatible with Coherent Gameface and Coherent Prsym
Fix Fixed starting animations that are initially defined with animation-state: paused
API Changed font metrics computation to be like in Chromium based browsers. to get the old behavior use the UseLegacyFontMetrics system option

Version – released 15 Jul 2019

Enhancement Updated Renoir backend to be compatible with Coherent Gameface and Coherent Prsym
Enhancement Added PlayStation 4 libraries compiled with SDK version 5.5

Version – released 06 Jun 2019

Feature Added support for binding wide strings
Enhancement Updated Unreal Engine 4 support to 4.22.2
Enhancement Updated PlayStation 4 SDK to version 6.5
Enhancement Optimized layer creation and composition
Enhancement Updated Xbox One SDK to 180704
Enhancement Improved the performance of pages with text in complex languages
Enhancement The Unity3D integration allows setting a disk cache
Fix Fixed calling thread wrappers for video files on PlayStation 4
Fix Fixed input-group API for textarea fields
Fix Fixed ignoring globalAlpha in some cases for canvases

Version – released 27 Feb 2019

Enhancement Improved performance when creating lots of dashed paths
Enhancement Improved throughput and reliability of WebSockets over SSL
Fix Fixed changing animation-iteration-count after the animation has started
Fix Guard against a crash when accessing a destroyed window object from JavaScript
Fix Fixed increasing memory usage for long running sessions with lots of garbage collection runs
Fix Fixed crash on Xbox One and UWP when there are outstanding HTTP(S) requests
Fix Fixed crash when changing pages without sychronizing all models in asynchronous mode
Fix Fixed several crashes and hangs when changing sizes of arrays exposed to the data-binding system
Fix Fixed division by zero floating point exception during garbage collection
API Fixed VirtualFree to be called with the correct size when virtual memory is to be released

Version – released 14 January 2019

Feature Added 4 new data binding attributes – data-bind-focus / data-bind-blur / data-bind-focusin / data-bind-focusout. These correspond to the focus events with the same names and extend the set of available data binding events. See the docs for more details
FeaturePS4 Added support for PS4 SDK 6.0
FeatureUE4 Added support for Unreal Engine 4.21.
Fix Fixed a crash caused when no user logging interface is provided and the default logger doesn’t have write access to the directory.
Fix Reduced memory usage of complex expression in the data binding system (e.g. expressions which invoke JS functions).
Fix Transparent elements having both background-color: transparent and a non-zero, non-one opacity will now be properly visible. Previously, they would be hidden as if they had opacity: 0.
Fix Fixed a rare crash in renoir::RenderingBackend::WrapUserTexture which would sometimes receive incorrect arguments.
Fix Fixed a potential crash caused our internal memory allocator attempting to free memory for the already destroyed GT system.
Fix Fixed a bug in the data binding system that would apply only one of multiple classes when using data-bind-class.
Fix Improved tracking of networking files downloaded to the disk cache. Previously, some of these files might become corrupted if the download was interrupted.
Fix Fixed a crash UISystem::UiserImagesChanged in async mode caused by a rare race condition.
Fix Fixed loadings fonts on page reload when the same fonts were previously requested and the request was still in flight.
FixPS4 Fixed a PS4 crash when reinitializing the GT system while a networking request was in flight.
FixU3DMacOS Fixed spamming the log on MacOS with OpenGL errors when using GT inside UGUI.
FixUE4 Fixed drawing the UI with respect to safe zones on UE 4.19 and before.

Version – released 24 Oct 2018

Feature Added support for dashed and dotted borders in CSS (border-style: dashed/dotted;) and SVGs.
EnhancementAPI Added a new option to the system settings (SystemSettings::JSCHeapSize). This is a recommended limit on how much memory the JavaScript Virtual machine should take. If more than that memory is allocated for JavaScript, the garbage collector will become very aggressive and try to free as much as possible. Tune with caution to your specific UI.
EnhancementAPI Added a new option to the system settings (SystemSettings::EnableInternalAllocator). Setting this to false will cause the SDK to directly call the user allocator. Setting it to true, keeps the current behaviour which is to use rpmalloc which in turn uses the user’s allocator.
EnhancementAPI Added a new method to the system (UISystem::RunGarbageCollection). This method forces the garbage collector to run immediately instead of whenever it decides.
Enhancement Promises returned by / engine.trigger are now standard ES6 promises. They were previously a custom implementation based on the now outdated Promise/A+ standard.
Enhancement Added docs about what to do to disable/sandbox the execution of JavaScript in cases when players can write HTML/JS for mods.
ImportantAPI As part of optimizing our rendering, changes were made to the rendering backends. If you are running GT in a custom engine, please make sure to use the new versions of the backends (e.g. the dx11backend). If you have a custom backend, ask our support team for migration guidelines.
Fix Fixed several memory leaks across the SDK. Most were related to image data that incorrectly persisted through system reinitialization.
Fix Fixed a crash due to buffer overflow in the data binding system.
Fix Fixed a bug which caused data-bind-class to not remove classes when necessary if applied to an element, within a component, within a data-bind-for. This caused elements to have multiple classes when only one was supposed to be had.
Fix Fixed a bug which caused changes to the DOM through innerHTML to be ignored by the data binding system.
Fix Fixed a bug which caused elements whose border-bottom-left-radius and border-bottom-right-radius differed to be rendered with the opposite corner’s value.
Fix Data bound arrays (e.g. exposing std::vector to the data binding) will now be printed as standard JS arrays in the debugger. Previously, doing console.log(myvector) would result in non-user friendly message.
Fix Fixed a potential rare crash when multiple elements refer to the same preloaded image / live view.
Fix Improved the algorithm which selects what font to use depending on the specified font-weight. This results in a choice much closer to what you would normally expect / see in most browsers.

Version – released 13 August 2018

FeatureAPI Added a new system setting (SystemSettings::PathTessellationThresholdRatio) that allows you to control how often does Coherent GT retesellates SVG paths. Until now, the SDK would retesellate the SVG when it was scaled by more than 250% (in either direction). With the new option you can change it to either optimize for performance (less tesellations) or smoother transitions between scaling levels (more tesellations).
FeatureUE4 Added support for Unreal Engine 4.20.
Fix Fixed a series of crashes caused by memory corruption when having multiple views and the system along with its views gets rapidly recreated.
Fix Fixed a very specific bug which caused data-bind-for to be evaluated incorrectly when using multiple copies of two nested for loops, the inner of which was iterating over a property of the outer’s iterator (e.g. repeating <div data-bind-for="player: {{model.players}}"><div data-bind-for="item: {{player.inventory}}"></div></div> multiple times).
Fix Loading data binding components from separate files (<link href="mycomponent.html"></link>) will now properly trigger the onload event on the <link> element.
Fix The error message “Failed to add class via data-bind-class because that class already exists” will no longer be spammed on each call to SynchronizeModels. Instead, it will only be logged once.
Fix Fixed a rare crash when recreating the system due to incorrect attempts to read font data.
FixWindows The SDK will now properly fallback to the system’s default font for Chinese when the Windows’ locale is set to Chinese Simplified. Previously, websites like wouldn’t display correctly under that locale.
FixXB1 The pdb files for icudtcoherent53.dll will now be properly included in all XB1 releases.
FixU3D Fixed washed out colors when running with OpenGL with Linear Colors in Unity2018.

Version – released 05 July 2018

Feature Extended the syntax of data-bind-for to also include information about the current index in the array. The new syntax looks like so data-bind-for="index, iterator: {{mymodel.myarray}}". This is a non-breaking change – you can still use the old syntax if you don’t need the index.
FeatureXB1 Added support for Xbox One XDK 180200.
Enhancement The syntax of data-bind-for has been enhanced. Previously, when accessing a value on an element in an array (meaning inside data-bind-for="{{it: mymodel.myarray}}") the only correct syntax was data-bind-value="{{it}}.myproperty" which was confusing since in all other places you can use a data bound property, you would put the brackets after .myproperty. With this release, the syntax data-bind-value="{{it.myproperty}}" is now also correct and can be used along with the old version.
FixMacOSLinux Users whose code compiles with enabled RTTI on MacOS and Linux will now be able to correctly link against the SDK even when their classes derive from classes in Coherent GT.
Fix Fixed a crash on exit caused by execution of late tasks for image decoding after the system is already in the process of being shut down.
Fix Fixed a rare scenario which would cause elements with animated values of background-image to disappear from screen upon reloading the page.
Fix Fixed a rare scenario which would cause old frame data to remain on screen if the root layer of the page was empty.
Fix Fixed a rare scenario which would cause text to be blurry and some parts of cut off.
Fix Clicking on an already selected text will now place the text caret at the correct location on MacOS.
Fix Custom Coherent::UIGT::IEventHandler implementations will now be properly destroyed. Previously, events registered via custom IEventHandler would cause the handlers to memory leak.
Fix Creating data models from the same type simultaneously from C++ and JavaScript will now work correctly. Previously, the SDK would erroneously mix them and attempts to access one of the models would actually read from the other.
Fix Using data-bind-for inside a data-bind-template inside a data-bind-for will now create all expected elements. Previously, elements in the innermost loop wouldn’t be created.
Fix Using data-bind-for with an array of pointers to other arrays will now create all expected elements. Previously, elements in the innermost loop wouldn’t be created.
Fix Custom Coherent::UIGT::IEventHandler implementations will now be properly destroyed. Previously, events registered via custom IEventHandler would cause the handlers to memory leak.
FixU3D Reloading pages containing live views will now work as expected. Previously, the live views would disappear.
FixUE4 Fixed a crash when trying to load an non-existent Unreal texture.
FixUE4 Fixed a potential crash when passing UStructs from Blueprints to JavaScript due to the plugin keeping weak refs instead of strong refs to the structs, which could potentially cause it to access deleted data.

Version – released 23 May 2018

Feature Improved performance by ~10% and fixed a couple of very rare crashes due to invalid memory access by replacing our internal allocator. We are now using a modified version of RPMalloc instead of NedMalloc.
FeatureAPIBreakingChange Changed the syntax of the CSS properties -coherent-custom-effect and -coherent-custom-effect-string*. Now, it’s mandatory to use quoted strings as the property’s value which allows you to use symbols that were previously invalid like slashes and quotes. (e.g. -coherent-custom-effect: "/path/to/my/effect").

If you are using custom effects in your UI, you need to add quotes to all the places you use them.

FeaturePS4 Added support for PS4 SDK 5.5.
Enhancement CoherentUIGT.dll on Windows, XB1 and UWP will now contain versioning information.
Fix Fixed Windows XP compatibility.
Fix Using font-family with multiple fonts (e.g. font-family: Font1, Font2;) will now work correctly. Previously, the correct font would only be used if the the first letter of the current text run existed in the fallback.
Fix Fixed a scenario which would cause elements in a scrollable list to be incorrectly clipped when the scroll amount exceeded some number.
Fix Fixed a scenario which would cause animated text to be incorrectly clipped after the animation ends.
Fix Fixed a scenario which would cause images displayed via border-image to disappear upon reloading the page.
Fix Fixed a scenario which would cause live views to disappear upon filling the internal image cache.
Fix Fixed a scenario which would cause elements with box-shadow to flicker.
Fix Fixed a crash caused by attempts to render a <canvas> element in the small window of time while a new page is being loaded.
Fix Attempts to update a data bound model before creating it from JavaScript will no longer crash. This is still invalid API usage but will instead lead to an error message.
Fix data-bind-if will now properly be evaluated to false if the model it refers to is still not registered.
Fix Event listeners attached via data-bind-[event] will now properly work with event.stopPropagation().
Fix Nested data-bind-for depending on the same collection will now work correctly.
Fix Fixed a crash upon unregistering a data bound model used inside data-bind-[event].
Fix Fixed a crash upon calling engine.updateWholeModel from JavaScript with a first argument which is not a valid model.
Fix Data bound models created from JavaScript will now be properly cleared on reload. Previously, they would linger after the reload but refer to no longer existing data.
Fix Attaching a new data bound model to DOM elements which previously had another model bound will now correctly update the DOM. Previously, the old valus in the DOM would linger.
Fix Fixed a bug which caused error messages triggered when sending data between JS and C++ to be repeated multiple times.
Fix Fixed a potential crash when handling gamepad input in asynchronous mode.
FixUE4 Mouse move events will no longer be fired every frame but only when the mouse is actually moving.
FixUE4 Fixed a bug which would cause live reloading the UI (refreshing local files when they change) to break on machines with slower hardware due to a race condition between file access.
FixUE4 Coherent GT will now respect DPI scaling when running inside an UMG widget (i.e. inside UCoherentUIGTWidget).
FixUE4 Fixed a bug which would cause parts of the UI to be clipped after a resize when Coherent GT is running inside an UMG widget.
FixU3D Fixed a crash when quitting the Unity3D editor while the game is still running.

Version – released 15 June 2018

EnhancementUE4 Support for Unreal Engine 4.19.
Fix The SDK will no longer cause floating point errors on PS4 if the application has enabled them.
Fix Using font-family with multiple fonts (e.g. font-family: Font1, Font2;) will now work correctly. Previously, the correct font would only be used if the the first letter of the current text run existed in the fallback.
Fix Fixed a race condition between calling View::ClearCache and painting a view which led to leaked cache textures.
Fix SVGs with the stroke: line-cap property will now be rendered correctly. Previously, they were displayed as if having stroke-linecap:square.
Fix Fixed a rare crash caused by the handle of an image being accessed after the image has already been destroyed.
FixUnity3D Local storage will now work without any extra setup necessary in our Unity3D plugin.
FixUE4 Coherent GT will now respect DPI scaling when running inside an UMG widget (i.e. inside UCoherentUIGTWidget).
FixUE4 Fixed a crash when trying to load an non-existent Unreal texture.

Version – released 17 April 2018

Feature Data binding in asynchronous mode now has a thread safe mode. Normally, usage of the data binding system in async mode required your objects to be thread safe. This new feature allows you to drop the thread safety requirement for your own objects and let GT take care of it. To start using the new system, you only need to call View::CreateModel(“modelname”, Coherent::UIGT::ByRefThreadUnsafe(MyModelPtr)) instead of View::CreateModel(“modelname”, MyModelPtr). See the docs for more info.
FeatureUE4BreakingChange Reworked the API for setting the limits of our rendering caches. All caches but one now support setting their limit in terms of both number of objects in the cache and total memory consumption.

This is a breaking change: The methods View::GetCacheStats / View::QueueSetCacheSize have been removed and replaced by 4 new methods with the extra functionality.

FeatureUE4 Added support for UE4 4.19.
Enhancement Data bound arrays now implement the Array.find and Array.findIndex
Enhancement Added mouseleave to the set of events that can be used in conjunction with the data binding system.
Enhancement The data binding events, can now be used everywhere in the global scope. Previously, they were only usable inside components created with data-bind-template-name.
Fix Fixed a crash caused by calling multiple C++ functions from JS within the same callstack (e.g. when a callstack crosses the JS -> C++ -> JS boundary multiple times).
Fix Fixed a crash caused by calling C++ functions from JS with the wrong argument count (e.g. sending 2 arguments when the C++ function only took 1).
Fix Fixed a crash caused by specifying data-bind-model before data-bind-for on the same HTML element. Ordering of data-bind attributes no longer matters.
Fix Fixed a rare crash on reloading multiple times in a quick succession caused by our data binding system not being properly uninitialized.
Fix Fixed a crash on trying to draw a <canvas> into another <canvas> while the first canvas is still not ready.
Fix Fixed a rare crash in our trial version caused by an invalid renderer object when attempting to draw the trial watermark.
Fix Floating point exceptions will no longer be raised by our code on PS4.
Fix Microsoft’s Application verifier will no longer issue warnings for code in the SDK.
FixU3D Fixed a crash when closing the Unity3D editor while the game is running and Coherent GT is in asynchronous mode.

Version – released 7 March 2018

Feature Added DX12 support. Added a separate sample solution / project for each native sample, demonstrating how to use DX12 on Windows. DX12 is now the default renderer in all Xbox One samples.
FeatureUE4 Added support for 4.19, Preview 3
Enhancement The data binding system will now detect and report many more instances of invalid usage, greatly improving debugging.
Fix Fixed a rare crash caused by attempting to repaint a table cell (<td>), that had already been deleted in the current frame.
Fix Fixed a crash in the data binding system caused by attempts to bind an array, stored on an address, that had previously been used to bind an array of another type.
Fix Fixed a crash in the Selenium implementation caused by a race condition between Selenium requests and the Coherent::UIGT::View becoming ready for script execution.
Fix A set of rare image decoding errors will no longer cause a crash but instead be reported in the log.
Fix Fixed а crash on reload in the inspector.
Fix Fixed а crash when trying to create a model in the data binding system out of a primitive value (number / string).
Fix Fixed rendering of horizontal/vertical SVG lines’ line caps. They were mistakenly treated as rectangles instead of lines and this caused the line caps to be ignored.
Fix Fixed a crash when attempting to start one of WebKit’s internal threads when a null pointer is passed to SystemSettings::ThreadWrapper.
Fix The inspector will no longer crash on attempts to preview preloaded images / live views.
FixU3D Local storage now works out of the box in Unity3D. Previously, users would have to set up the local storage path manually.

Version – released 21 February 2018

Feature Added support for events to the data binding system. You can now use all standard mouse and keyboard events as data binding attributes (data-bind-click, data-bind-keydown). Event handlers bound in this way get access to a couple of new variables that allows you to work with other bound data. For example this allows you to bind a different click handler for each element in a data-bind-for. See the docs for further details.
EnhancementAPI Support for PS4 SDK 5.0.
Enhancement You can now provide a callback which GT will use when spinning off its async thread (when asynchronous mode is on). This allows you to do any thread-specific setup needed.
EnhancementUE4 Our UE4 plugin is now hooked up with the UE4 crash reporter on Windows. Crash reports in async mode will now be properly reported.
API IMPORTANT: We no longer distribute CRT libs in our Windows builds. We now require all users to install the VS2015 redistributable on their players’ machines.
Fix The data binding system now properly supports binding different types to the same pointer. Previously, if a user type had another user type as his first member the system would erroneously complain about incorrect API usage because the two objects would have the same address.
Fix Attempts to load .woff or .woff2 fonts will now trigger a ‘Not supported’ warning instead of crash.
Fix Fixed compatibility with Windows Vista.
Fix Views created with VLP_IgnoreCache will now properly reload all of their resources. Previously, images and JavaScript files would sometimes be reused instead of reloaded.
Fix Fixed a crash caused by creating enormous <canvas> elements which would attempt to create enormous GPU textures.
Fix HTML elements whose background-image is a gradient and whose background-size is smaller than their width / height will no longer disappear after certain time has passed.
Fix HTML elements whose background-image is a SVG will no longer disappear in certain rare cases.
Fix HTML elements with background-image or border-image will no longer disappear after navigating away from and back to the same page.
Fix Live views which were removed from the page and then added a second time will now work as expected. Previously, they would freeze and only display the last frame before DOM removal.
Fix Fixed a bug which caused breakpoints in the Inspector to be incorrectly set several lines above or below the actual click location. Issue was caused by a third party not taking into account Windows line endings (CRLF) and only computing the offset by measuring LF characters.
Fix Fixed a crash that would occur randomly in the Inspector when switching between panels.
FixXB1 Parsing date objects in JavaScript in the local time zone now works correctly.
FixUE4 Fix a series of compile-time warnings that our plugin caused.

Version – released 22 Dec 2017

Feature Added new JavaScript API that allows JavaScript code to listen for changes in the data models. The new function engine.addModelChangeListener(model, propName, callback) will cause callback to be called anytime the property propName of the model model is changed. See docs for more info.
Feature ViewRenderer::Paint now paints only a single frame. Previously, it would paint all recorded frames which causes issues with engines whose main thread and rendering thread are separated by several frames. This required breaking the API at multiple places: View::Layout and View::RecordRenderingCommands now both return a frame identifier. You must pass that identifier back to ViewRenderer::Paint or ViewRenderer::PaintToTexture. See the docs or the update samples for more info.
FeatureUE4 Added support for Unreal Engine 4.18
Enhancement Updated all of our samples, the Unity3D and UnrealEngine 4 plugins to use the new ViewRenderer::Paint API.
Enhancement ViewRenderer::PaintToTexture can now paint into a user-specified rectangle, which doesn’t cover the entire render target. This means that ViewRenderer::PaintToTexture, which is usually used to render the UI directly in the game’s backbuffer, can now respect special screen boundaries like letterboxing and TV safe zones.
EnhancementUE4 Added new API for providing the GT license in the UnrealEngine4 plugin. Previously, the only way to provide the license would be to place the LicenseGT.h header in a specific directory. With the new API you can dynamically provide different licenses. This is useful when multiple games are developed with the same engine but have different licenses.
EnhancementUE4 Our sample game is now based on a more modern version of the UnrealEngine4 FirstPersonShooter template.
Fix Fixed a crash when one tries to pass a number to data-bind-model. This is still unsupported but will instead log an error message instead of crashing.
Fix Fixed the frame selector dropdown in the inspector. This allows you to switch between active frames and run JavaScript code in the console even in nested <iframe>.
Fix Sending the same mouse event to two separate views will now work correctly. Previously, due to some static housekeeping data, the second view would have treated clicks as double clicks.
Fix Fixed calling View::AuditPerformance with a nullptr for frame selector the second time its called.

Version – released 6 February 2018

FeatureUE4 Added support for Unreal Engine 4.18
EnhancementAPI Support for PS4 SDK 5.0.
Enhancement Users can now provide a callback which GT will use when spinning off its async thread (when asynchronous mode is on). This allows users to do any thread-specific setup needed.
EnhancementUE4 Our UE4 plugin is now hooked up with the UE4 crash reporter on Windows. Crash reports in async mode will now be properly reported.
Fix Fixed a crash in the data binding system caused by using data-bind-for with an array whose size is changed while the data-bind-for is being evaluated.
Fix Fixed a bug which would cause data bound models to persist after page reload / URL change.
Fix Fixed a bug which would cause text with negative letter spacing to be incorrectly rendered.
Fix Fixed a GPU memory leak caused by some auxiliary textures being incorrectly tracked.
Fix Fixed a crash in our resource loading system caused by attempts to double delete a resource response.
Fix Fixed a crash on page reload caused by the engine object persisting on certain pages.
Fix Sending the same mouse event to two separate views will now work correctly. Previously, due to some static housekeeping data, the second view would have treated clicks as double clicks.
Fix Fixed a bug in WebKit which caused CSS animations to sometimes extrapolate values outside their allowed range. This caused some values to grow into huge numbers and generate enormous elements or elements positioned far beyond the visible part of the page.
Fix Fixed compatibility with Windows Vista.
Fix Fixed a crash caused by creating enormous canvas elements which would attempt to create enormous GPU textures.
Fix User types with a ‘length’ property are now properly serialized. Previously, they would be erroneously treated as arrays.
FixU3D Triggering .NET delegates from JS in AOT mode will now work correctly. Previously, it would crash the game.

Version – released 7 December 2017 – see blog post

Feature Updated internal WebKit version to Safari Technology Preview (STP) 34. Closest browser comparison would now be Safari 10.1.2 as opposed to Safari 6 for GT 1.14.5.
Feature Enhanced JavaScript support by adding complete support for EcmaScript 6, most notable features of which being:

Feature Enhanced JavaScript support by adding complete support for EcmaScript 7
Feature JIT is now enabled on all platforms which allow for it (Windows, OSX, Linux). This produces a huge performance boost for JavaScript execution on the supported platforms. Note that this also creates a performance disparity between PC and consoles – if you are developing on consoles, make sure to test JS performance there first.
Feature Added support for CSS variables
Feature Added support for CSS grid
Feature Added partial support for CSS4 selectors.
Feature Added support for the HTML template element
Feature The inspector (debugger) was also updated to the feature level of STP 34. It has a brand new design and a plethora of new features. Some examples being:

  • DOM and XHR breakpoints – set breakpoints which stop script execution when JS changes the DOM tree or makes a XHR request
  • Brand new Timeline panel which allows you to profile performance
  • Brand new Layers panel which allows you to inspect what elements cause layers and why
Enhancement Added support for the ‘Inspect element’ button in the inspector. It allows you to hover over elements on the page and clicking on it will lead you to its source code.
API Parts of the public API contain breaking changes. See the transition guide in the docs about how to upgrade to GT 2.0. Some notable changes:

  • Allocator interface has been extended with methods for aligned allocations and allocations of executable memory for the purposes of JIT.
  • All live view specific methods have been removed. Live views are now an extension of the preloaded images which makes implementing them much easier.
  • Removed several public methods which were unused.
API Parts of the HTML standard have changed in the recent years. GT 2.x works according to the latest standard which might not always be the same as GT 1.x. The transition guide in our docs contains a description of those cases.

Version – released 20 September 2017

FeatureAPI Added support for Media Source Extensions (MSE) as an experimental feature. MSE allows you to play high-quality videos from YouTube at the cost of being unable to seek. This feature is currently unstable so it’s disabled by default. SetViewInfo::EnableExperimentalMediaSourceAPI to true to enable it.
Fix Fixed compatibility with Windows XP.
Fix Fixed unicode support for strings in complex evaluators in the data-binding system. A ‘complex evaluator’ is any data-binding expression that’s not simply reading from some property e.g. concatenates strings, invokes a function, etc. East Asian and other non-ASCII text will now be evaluated and displayed properly.
Fix ViewListener and ResourceHandler are now compiled with RTTI enabled. This allows clients compiling with RTTI to derive their implementations from them without getting linker errors.
Fix Fixed a crash on view destruction when the ViewRenderer is being destroyed but the main thread is in View::UpdateStylesAndLayout / View::Layout.
Fix Fixed a crash on view recreation caused by attempts to paint an image that was never used.
Fix Fixed a race condition and a crash when using asynchronous mode and TriggerEvent
Fix Fixed a minor memory leak on view destruction when using async mode.
Fix Fixed a crash caused by a web socket disconnecting as a result of handling a message.
FixXB1 Fixed a crash on XboxOne in our networking subsystem caused by an AJAX request attempting to access freed memory in its onError callback.
FixUE4 Fixed a crash during the first attempt to move the mouse over the UI on low-end GPUs.

Version – released 22 August 2017 – see blog post

Feature Added support for bitmap fonts. Usually GT reads the font files itself and then decides whether to rasterize the font glyphs or to use SDFs. This feature allows you to provide GT with bitmap fonts (e.g. textures which already contain the glyphs). This gives you more control over font rendering and to reuse resources if you already use the bitmap fonts for other parts of the engine.
FeatureUE4 Added support for managing data models via Blueprints. See the CreateDataModel / UpdateWholeDataModel / SynchronizeModels method on the UCoherentUIGTBaseComponent class.
FeatureUE4 GT can now run in UE4’s loading screen. This allows you to present the player with a far more interesting transition compared to what’s available in Slate. This feature is highlighted in our new sample (LoadingScreen_Map) which can be found in the sample game distributed with the plugin.
FeatureUE4 Added memory tracking to for both RAM and VRAM. See the stat CoherentGTCounters console command.
FeatureUE4 Added support for UE4 4.17.
Enhancement Improved the performance of sending data between C++ and JavaScript via calls to engine.trigger / Coherent::UIGT::View::TriggerEvent in asynchronous mode by about 50%.
EnhancementUE4 The automatic binding of UClasses and UStructs no longer requires a specific ordering of include headers. Previously you had to include "CoherentUIGTUTypeBinder.h" before any other GT header.
Fix Text rendering will now properly take into account the font’s kerning when rendering the caret and the selection range.
Fix HTML components containing east-asian text will now display properly.
Fix Fixed a series of compile-time warnings that our rendering library Renoir would cause when compiling with Clang due to undefined preprocessor macros.
Fix Fixed a bug, which caused elements to be improperly clipped when a layer’s size is not a multiple of 64.
Fix Fixed a regression which caused the CSS outline property to have no effect.
Fix Fixed a bug in video playback which would result in a black screen because the video decoder tried to read leftover data from previous frames.
Fix Fixed a bug which caused our samples to sometimes appear transparent and show the user’s desktop behind them.
Fix Using multiple properties of the data model in a data-bind-class-toggle expression no longer results in a crash.
FixUE4 Fixed a bug which broke the Live Reload feature of the plugin (automatically refreshing the game’s UI whenever some of its resources changes). The feature still needs to be enabled from the plugin’s options.
FixUE4 Binding Blueprint-only UStructs will now properly send their properties’ names to JavaScript. Previously the property names of such structs would be unusable in JS, as UE4 generates random suffixes to all of these properties
FixU3D Fixed a crash on exit in async mode.
FixU3D Fixed a crash that would manifest if the user never send data between C++ and JS in async mode.

Version – released 24 July 2017 – see blog post

Feature The data-binding system can now be fed data from JS. Frontend developers can use this feature to mock game data and test the UI without running it in the game. Similarly, they can use JS-specific values. Data models can be created directly from JS and existing C++ data models can be extended further.
Feature Added support for complex script languages, most notably Arabic, to all GT text.
Feature Added a new sample demonstrating how to automate UI testing via Selenium.
Feature Improved overall video playback performance by 40-60% depending on the video quality. Added multithreading support for decoding.
FeatureAPI Rendering commands can now be recorded and saved on disk. This allows us to replay frames without the HTML resources and improve debug times on rendering issues. See Coherent::UIGT::View::CaptureSingleDebugFrame for more info.
FeatureU3D Added support for 64-bit Linux.
APIU3D Added support for Unity2017
APIU3D Dropped support for all versions prior to Unity3D 5.4
Fix Fixed a memory leak caused whenever an array property was exposed through the data-binding system.
Fix Fixed a crash in video playback caused by rapidly seeking forwards.

Version – released 3 July 2017

Fix Fixed a few rendering artefacts introduced in
Fix Fixed a crash caused by the video player incorrectly freeing data that was still used.
FixPS4 DNS resolving on PS4 is now asynchronous. The game will no longer hang if the network connection fell appart while DNS resolving was in progress.

Version – released 23 June 2017 – see blog post

Feature SVG rendering has been completely rewritten. The new tesselator produces much smoother results, especially when the SVG has thin details (e.g. cat’s whiskers). The performance has also been significantly improved. See the blog post for more details.
FeatureAPI Added on-screen performance information that lets you inspect the time GT takes to do most of its work both on the main thread, the rendering thread, and on the GPU.
Feature The GTPlayer can now visualize the aforementioned performance information. See the blog post for more details.
Feature The data-binding system now allows you to bind to the CSS properties class, background-image, and transform. This allows you to synchronize more data between the UI and the game. See the blog post linked above for examples. The relevant data-binding attributes are data-bind-class, data-bind-background-image-url and data-bind-transform2d attributes.
Feature The component system can now automatically register components. Until now, component registration required JavaScript code but with this release component registration is simple as putting your component in an element with the data-bind-template-name.
Feature The component system can now import components from other files. It was previously required to put all of your components in the same file.
Feature Support for PS4 4.5
FeatureUE4 Support for UE4 4.16.
APIUE4 Removed support for all UE4 versions prior to 4.10.
FeatureU3D Support for Unity 5.6.
Enhancement A new inventory sample has arrived in GT native and the UE4 sample game. It demonstrates the usage of components and data-binding through the example of an inventory screen with pagination and sorting.
Enhancement Dirty rectangles (the rectangles which show what parts of the page have been changed) received a visual improvement and will now disappear gradually to better show what has changed.
Enhancement The performance guide has been greatly expanded with useful tips on measuring and maximizing performance.
Fix Fixed a rare crash that would occur when loading image files on a congested network.
Fix Fixed a small memory leak when data-binding arrays caused by improper destruction of some internal JS objects.
Fix Fixed a memory leak when using our localization API via JS (engine.translate / engine.reloadLocalization) caused by improper destruction of some internal JS objects.
Fix Missing resources loaded via coui:// will now properly fail with error 404 instead of remaining pending for an indefinite amount of time.
Fix Fixed a rare crash that would occur when loading large video files.
Fix Fixed a memory leak introduced in GT 1.12.5 when playing video files because of improper destruction of a video decoder.
FixU3D Fixed an issue which caused mouse input to be incorrectly forwarded to views not attached to the main camera.

Version – released 22 May 2017 – see blog post

Feature Reworked the GT Player. When launched it will now offer the following set of tools via a panel at the top of the page:

• The ability to quickly inspect paint rectangles and layer borders without attaching the debugger.

• A set of browser-like features: going back & forward / reloading / typing the url of a page to be loaded.

• Shortcuts to other GT tools – you can now run the debugger, Coherent Editor, and auditor directly from GT Player.

• A set of keyboard shortcuts to simplify using the aforementioned.

• Gamepad support (Gamepad support has been part of GT since 1.6, but the GTPlayer didn’t forward gamepad input to GT)

• Drag & drop support for HTML files

• A tutorial to guide new users through its capabilities.

• The ability to retain the old behaviour by hitting CTRL + SHIFT + F or running with -forfeitui

Feature Reworked the Coherent Launcher – it is now much more easier to start (from a shortcut in the native package) as it no longer needs installation. The Coherent Launcher is a tool that let’s you find everything GT-related in a single screen and has been part of GT releases for a while but it is now easier to discover and use.
Feature Reworked the HTML documentation – it now sports a modern look with better UX. The search functionality has been greatly improved and will now search through more places including page contents and API reference instead of only page titles.
FeatureAPI Added the View::ShowLayerBorders method that let’s you toggle visualization of composited layer borders from C++ directly. Use this hook to show the layers directly while the game is running so that UI designers can understand what elements have become layers during development without having to use the debugger.
FeatureAPI Added a second optional argument to View::ExecuteScript & View::AuditPerformance specifying in which frame to run. This lets you execute JavaScript / run the auditor in any iframe in the page.
Enhancement The auditor can now run on pages that don’t include coherent.js.
Fix Fixed a crash caused by infinite growth of the memory taken by instances of the JS Map class. Removing elements from the Map will now properly reduce memory taken.
Fix The style animation cache optimization (enabled via SystemSettings::FeatureList::UseCSSAnimationStyleCache) will now automatically disable itself on elements whose styles contain inherited properties during parent animation of said properties. In these cases the optimization would break correctness and caused some rendering artefacts. This change make the optimization usable on more pages (resulting in ~10-15% performance gain in frame time).
Fix Fixed a memory leak caused by reloading views using ByRef binding.
Fix Fixed a crash caused by painting to hidden <canvas> elements. Issue was caused by GT not executing rendering commands for hidden canvases which caused commands to accumulate without bound. Rendering commands will now be dropped and a warning issued in the log.
Fix Fixed a crash on destruction of views for which no frame was ever painted caused by attempts to cleanup non-existing rendering resources.
Fix Fixed a rare crash caused by the image decoder incorrectly trying to decode more frames than a given .gif image has.
Fix Fixed a hang in asynchronous mode when two threads make overlapping calls to UISystem::WaitFor. It is now safe to call UISystem::WaitFor from multiple threads at any time. This hang manifested during startup in UE4 where contention between the main thread and the rendering thread deadlocked the engine.
Fix Resizing the view no longer causes video elements to produce black screen when using DX9.
Fix Fixed a memory leak on reloading views when using custom fonts caused by font glyphs being recreated each time.
Fix Fixed a crash in our rendering library caused by a race condition that allowed multiple threads to gain access to memory that should be only accessible to one thread at any given time.
Fix Fixed a deadlock that would occur randomly in the image decoder thread caused by improperly timed mutex lock.
Fix Fixed a bug which caused valid pointers to textures to reach the rendering backend as null pointers when using preloaded images in asynchronous mode.
FixUE4 Fixed a memory leak caused by using the blueprint method CoherentUIGTJSEvent::AddGenericStructArg. Issue was due to incorrectly freeing the memory of FString and other non-trivially destructible members of the USTRUCT argument.

Version – released 04 May 2017

Enhancement The data binding system has been optimized all around. Most notably, updating elements with data-bind-value and data-bind-for has been sped up by 30%.
FeatureAPI GT components can now be instantiated and removed from C++ giving developers the option to spawn them dynamically from code. This has been added for flexibility purposes as all other ways of spawning components required going through either
data binding or JS code.
Fix Fixed a memory leak which leaked several KBs which was caused by unfreed static data during view destruction. Memory usage now remains constants no matter how many times the view has been recreated.
Fix Fixed a rare hang during image decoding caused by an infinite loop during decoding because of an improper frame count computation.
Fix Fixed a bug which caused setting the values of style properties to numbers with very small fractional parts to be ignored. Most notably, when attempting to set values close to zero e.g. 1e-10, the setter would fail and instead leave the
last known value in use which caused JS animations to fail around 0.
Fix Fixed a crash caused by using a view without a view renderer – allowing views to run without active rendering.
Fix Fixed an issue which caused simultaneously playing 2 or more CSS animations, each containing different easing functions per keyframe (via animation-timing-function), to use the easing function of the first animation for all animations.
Fix Fixed a crash in our video player sample on OS X when running in asynchronous mode caused by attempts to render during shutdown.
Fix Fixed a crash in our multiview sample on DX9 during resize caused by recreation release of rendering resources.
EnhancementUE4 Added a draw call counter to the CoherentGTCounters. You can now use stat CoherentGTCounters to inspect how many draw calls GT does. Previously only the total number of rendering commands was available (rendering commands include any change
to the GPU state such as binding textures and shaders.)
EnhancementUE4 The test driver’s port can now be set from the plugin settings, the test driver being the subsystem that allows for automated UI testing via selenium. If you are unfamiliar with the test driver, see our native documentation for more details.
FixUE4 Reduced the size of the .zip archive our plugin by no longer packing unnecessary binaries
FixUE4 Disabled the AddPlane menu item while the game is running in the UE4 editor as it shouldn’t be used while the game is running.

Version – released 30 March 2017

Enhancement Greatly improved websocket support – moved blocking or expensive operations out of the main thread and increased throughput 16 times.
Enhancement All samples now support command-line arguments akin to the GTPlayer (e.g. -renderer dx11/dx9/opengl to change the renderer, -vsync 0/1 to turn vsync on/off, etc.)
EnhancementUE4 Exposed the SCoherentUIGTWidget::SetReceiveInput / SetReceiveInputWhenTransparent methods
Fix Animation timing functions are now properly used in the rare case when an element has multiple animations attached to it and at least two animations override the animation-timing-function property in their keyframes.
Fix Custom SSL certificates now work correctly on PS4.
Fix Fixed log spamming by the ‘Missing surface’ error caused by improper management of an internal texture.
Fix Fixed a crash on exit in the sample application on XB1 caused by incorrect OS event processing during shutdown.
FixUE4 Removed several incorrect warnings caused by resource loading issues, especially resources used by the Coherent Editor.
FixUE4 Attempts to preload textures with an unsupported texture format will now result in warnings, not crashes.
FixUE4 Scrolling elements with overflow: hidden; no longer causes other layers to leak as background on top of the scrolled element.
FixUE4 Fixed a crash caused by running the auditor on a HUD view when starting the game in Simulate instead of Play.
FixUE4 Fixed a crash on startup caused by improper usage of rendering queries when the mouse did not start inside the game’s window.

Version – released 8 March 2017

Feature The component system now supports re-registration of components. This allows you to change the template of an already registered component. Already instanced components attached to the DOM will be updated with the new structure.
Feature The component system now supports unregistration of components. Already instanced components will be removed from the DOM.
Enhancement The data binding system now supports nested ‘for’ loops. This allows you to create much more complex templates by binding arrays of arrays (and so on) (e.g. a list of stats for each item in an inventory).
Fix Fixed a bug which caused images shared by multiple views to disappear if one of the views is destroyed while the others are still active.
Fix Fixed a graphics artefact when resizing the page which caused elements to sometimes disappear behind SVG masks when they shouldn’t.
Fix Fixed a crash caused by a race condition during loading heavy pages utilizing preloaded images.
FeatureUE4 Support for Unreal Engine 4.15
FixUE4 Running on PS4 with GNM validation enabled no longer cause errors.
FixUE4 Fixed a crash caused by attempts to load preloaded images while UE4 is running garbage collection.

Version – released 07 Feb 2017

Fix Fixed two instances of memory leaks caused by recreating / reloading views.
Fix Fixed a crash caused by the garbage collector running during View::TriggerEvent.
Fix Fixed multiple crashes caused by memory corruption when multithreaded rendering was used and the rendering thread switched too often.
Enhancement The CSS animation cache optimization that was added in is now
disabled by default as it currently causes incorrect rendering in some rare cases.

Version – released 27 Jan 2017

Feature Users can now modify all HTTP headers in requests and provide additional data
Feature Improved the Component system to better support nested data-bound elements
Feature Views now support zooming the content in a browser-style standard way. Users can control the zoom levels through a new API.
Enhancement CSS animations are now evaluated ~30% faster. Pages with many animations will see large performance improvements.
Enhancement Added a new API for user control over the allocations of temporary textures
Enhancement Engine (C++) arrays exposed by reference now behave in JavaScript as-if they are standard JavaScript arrays
Enhancement Added PDBPATH to Windows and XboxOne builds to aid user debugging
Enhancement Calls to callbacks that throw exceptions are now logged to aid debugging
FixUE4 Fixed a rare crash when the Coherent GT Player window is resized
FixUE4 The gamepad state is automatically reset when focus is lost. This aids input management with gamepads

Version – released 13 Dec 2016

Enhancement Removed extra Layout happening from time to time in UISystem::Advance.

This change will trigger changes in the performance profile of the Coherent GT – UISystem::Advance will be faster on average and less spiky, while View::Layout might get a little bit slower on average.
Fix Fixed memory leak when using the data-binding API
Fix Fixed a rare crash on PlayStation 4 when an SSL secure connection is re-established mid-session
Fix Fixed a crash when “backspace” is pushed on a keyboard connected to a PlayStation 4 or Xbox One and input in a GT text field
Fix CSS filters can now be animated with CSS animations to create amazing UI effects

Version – released 30 Nov 2016

Fix Fixed handling text with letter spacing
Enhancement The sample FileDiskCache keeps the running requests open and is significantly faster
Feature UE4 Support for Unreal Engine 4.14
Feature UE4 USTRUCTs can be exposed recursively to and from JavaScript


Added a GPU stat counter, available via stat GPU

Version – released 21 Nov 2016

Fix Fixed hang on quit with HTTP requests containing redirects
FixUE4 Fixed audio in Unreal Engine 4 for PlayStation. Note: the engine has to be patched with the Epic’s commit CL 3149552 at the WIP shelved changelist
Enhancement Shipping with Coherent Editor

Version – released 01 Nov 2016

Feature Any image can be
preloaded using the ResourceResponseUIGT::ReceivePreloadedImage API
Feature Mix-blend mode support
Feature Structural data-binding with data-bind-if/switch/for attributes
Fix Fixed text rendering for fonts with kerning
Fix Fix memory leak when reloading pages (COH-2182)
FeatureUE4 Coherent GT’s HUD can now be drawn over letter-boxing
FixUE4 Setting input propagation behaviour will now correctly propagate gamepad and keyboard events
FixUE4 Fixed a driver crash when playing video on Xbox One
APIUE4 Preloaded image API has changed – see the documentation for migrating to the new API.

Version – released 14 Oct 2016

Feature Added an optional file manipulator for font loading
Fix Fixed system hanging in asynchronous mode
Fix Fixed system hanging in image decoding thread
Fix Fixed clang compiler being detected as GCC
Fix Fixed leaking of CSS Length values (COH-2776)
Fix Fixed live views creation race condition
Fix Fixed live views creation race condition in Unity3D
Fix Fixed error msg saying live view protocol not supported
Fix Fixed returning value from C++ method for classes with more than 32 methods
Fix Fixed calling C++ method on the wrong instance when ByRef binding is used
Fix Fixed crash due to JS value corruption after GC run on 32bit Windows (COH-2711)
FeatureUE4 UStruct binding via Blueprints.
FeatureUE4 Added support for Unreal Engine 4.13


The internal memory allocator now uses FMemory instead of GMalloc which enables memory tracking.
FixUE4 Font files are now read from Content/Fonts and dll’s on Windows are packaged.
Fix Fixed packaging and launching from the editor for consoles
IssueUE4 Audio playback for PlayStation 4 is disabled, due to limitation of Unreal Engine 4 audio system
IssueUE4 Certain videos can cause a crash on Xbox One

Version – released 31 Aug 2016

Feature Support for transparent videos – using the “alpha_mode” video track property of the WebM container
Feature Support for Universal Windows Platform
Enhancement Support for two-way binding of objects exposed by reference
Fix Fixed crash due to JavaScript value corruption after garbage collector run on 32-bit Windows
Fix Fixed returning value to JavaScript from C++ methods for classes with more than 32 methods
Fix Fixed calling C++ method on wrong instance in certain cases
FixUE4 Internal events will no longer cause errors during immediate view destruction (COH-2600)
FixUE4 Fixed an issue which caused BP binding of UObjects to use UObject instead of the actual object’s type.
FixUE4 Focusing GT’s slate widget prior to complete view creation no longer causes a crash (COH-2625)
FixUE4 Quickly removing UMG widgets will no longer cause a crash on GC in async mode (COH-2709)
FixUE4 Attempts to set focus on GT components during engine shutdown will no longer cause a crash (COH-2658)
FixUE4 Fixed an issue which caused attempts to fetch mouse queries without issuing them apriori (COH-2701)

Version – released 15 Aug 2016

Feature Mac OS X i386 support
Feature Data-binding syntax to allow for automatic update of the DOM based on values of C++ objects
Feature Coherent GT supports the WebDriver API and can be used with Selenium WebDriver
Enhancement Improved auditor with new warnings, docs and keybindings
Enhancement Improved the performance of methods calculating the composition of layers
Feature Support for adding custom effects – filters
Feature Clients can control the texture composition of layers
Enhancement Introduced “thin” layers (surfaces) that have no backing textures, to reduce the amount of GPU memory used
Enhancement Content rectangle can be specified for preloaded images

Version – released 05 Jul 2016

Feature Support for pre-loading images
Feature Support for pre-loading fonts
Feature Support for custom font directories
Feature Support for annotating GPU texture objects with debug names for easier identification during graphics debugging. Use the SystemSettings::SetRenderingResourcesDebugNames flag to enable the annotations
Enhancement Improved JavaScript property access performance for instance binding by 20%
Enhancement Improved JavaScript method invocation performance for instance binding by 10%
Fix Fixed a crash when playing videos with loops
FeatureUE4 Support for using Unreal Engine 4 textures directly in the UI

Version – released 28 Jun 2016

Feature Coherent GT Debugger works for Xbox One
Feature Coherent GT Debugger works for PlayStation 4
Enhancement Changed ViewInfo::AnimationFrameDefer default value to guarantee smooth animations
API The OpenGL backend now needs two GLuint representing the names of the textures for render target and depth stencil
API Disabled by default the scrollbars from the page styles. To add the scrollbars again, use the ViewInfo::EnableAdditionalDefaultStyles flag.

Having scrollbar styles on all elements can cause performance degradation. Note that pages that used the default scrollbars will not have them now. We recommend to keep the option off on all pages where the user has
control of the content and add scrollbars only on the CSS classes of elements that really need them. For more information please refer to the Performance guide.
Fix Fixed a crash when tessellating certain stroke patterns
FeatureUE4 Support for Unreal Engine 4.12

Version – released 06 Jun 2016

Feature Lazy JavaScript binding for arrays exposed by reference
Feature Support for DDS textures in BC1-5 format
Feature Support for PSD and TGA images
Enhancement Enhanced the GT Player to show errors
Enhancement Applied different formula for YUV to RGB conversion which preserves video colors better
API Added Coherent::UIGT::Binder::ReadNull method that allows reading of null types
API Added a new callback in Coherent::UIGT::ViewListenerOnLiveViewActivate. It’s fired when the internal components for the live view are activated or deactivated
API Added new method UISystem::HasLastAdvanceCompleted which checks whether calling Advance on an asynchronous UI System would block waiting the previous Advance to complete
API Added new method View::HasLastLayoutCompleted which checks whether calling Layout (or ExecuteJSTimers/UpdateStylesAndLayout/RecordRenderingCommands) on an asynchronous UI System would block waiting the previous Layout operation
to complete
Fix Fixed the calculated size of a stoked text
Fix Fixed possible crash on quit when using canvases
Fix Fixed a memory leak caused by unfreed image data
Fix Access to the sync view during async destruction on some methods
FeatureUE4 Automatic exports for USTRUCTs and UCLASSes
FeatureUE4 SVG files are visible in the content browser
FeatureUE4 Added stat commands for GT and helper console commands


The GTPlayer now supports changing the page and reloading after launch
FixUE4 Fixed a major memory leak caused by not destroying the view’s texture
FixUE4 Fixed a crash during multiplayer game setup

Version – released 14 April 2016

Feature Coherent GT supports running on Linux
Feature Exposing C++ objects to JavaScript by reference
Feature Exposing methods of C++ objects to JavaScript by reference
Feature Control over the storing location for cookies – API
Feature Control over the for localStorage
FeatureUE4 Unreal Engine 4 games with Coherent GT can be built for Linux
EnhancementUE4 Support for Unreal Engine 4.11

Version – released 23 March 2016

FeatureUE4 Live-reload support for Unreal Engine 4


Support for Unreal Engine 4.11
Enhancement Updated OpenSSL to 1.0.2f
Enhancement Automatic detection of resource types for http and https
Enhancement Video player sample
Fix Support for videos with arbitrary frame sizes

Version – released 18 Feb 2016

Feature Implemented rendering based on the Renoir graphics
that improves rendering and command recording performance
Feature Support for BC3 compressed textures (DDS format) on all rendering backends
Enhancement Bundled new Coherent Editor 1.3
Enhancement Significantly reduced memory usage
Enhancement Introduced a new CSS property -coherent-layer-clip-aa:
that allows control over which elements have anti-aliased clipping
Enhancement Reworked image and texture management
Enhancement Introduced effect caches for cheaper special effects (filters, blurs)
Enhancement Improved image decoding performance and all image decoding happens on a worker thread
API Renoir backends are now available as source code and can be modified by developers
API Removed dependency on libEGL, libGLES2, and DirectX11. New Renoir rendering backends are available for DirectX 9, DirectX 11, OpenGL 3.3+, GNM
API Control over rendering and font caches
Fix Fixed border image repeat mode
Fix Video loop playback
Fix Coherent Editor is now packaged as dmg on Mac OS X
Enhancement Sample application for Microsoft Xbox One
Enhancement Added a new default sample interface that is editable with the Coherent Editor
Documentation Removed all samples that were using the GSAP animation library

Version – released 14 Dec 2015

FeatureUE4 Support for Unreal Engine 4.10.1

Version – released 01 Dec 2015

Enhancement Improved performance of CSS animations
API Added SystemSettings.AnimationFrameDefer to allow controlling the update rate of CSS animations and transitions
API Added a a new field “IsSystemKey” in Coherent::UIGT::KeyEventData

This field denotes whether the event is tagged as a “system key” by the OS and is generally set to true when the Alt key is held down, but not the AltGr key (if present on the current keyboard layout). If you need to keep the previous
behavior you can set this field to the same value as
FeatureUE4 Coherent GT supports binding Array to JavaScript in Blueprints
EnhancementUE4 Improved Mouse Input integration

Version – released 18 Nov 2015

FeatureUE4 Support for Unreal Engine 4.10

Version – released 12 Nov 2015

Fix Fixed loading of external JavaScript and CSS sources in Coherent Editor

Version – released 11 Nov 2015

Feature Localization API for GT.
Fix The :active pseudo-selector is now activated only on left clicks
Fix Fixed playing video with higher than 480p resolution served by some HTTP servers
Fix Crash when opening requires h264 or Flash to play videos and is not supported in Coherent GT
EnhancementUE4 Updated the Unreal Engine 4 Localization sample to use the new localization API
FeatureUnity3D Unity3D inspector events for Views and Binding
FeatureUnity3D Gamepad support and sample for Unity3D
FeatureUnity3D Localization API and sample for Unity3D

Version – released 27 Oct 2015

Feature Gamepad API support
Feature Coherent Editor 1.0
Feature Added method on View for changing the Media Type
Feature Coherent Editor for Mac OS X
Feature Support for CSS cursors
Enhancement Cache policies are honored for XHR requests


Added new Unity3D game sample


Removed per-frame memory allocations in Unity3D
FixUnity3D Fixed crash on exit in Unity3D
FeatureUE4 Gamepad API support for Unreal Engine 4
FeatureUE4 Mouse Cursor API for Unreal Engine 4


Simplified the Localization Menu HUD


UE4 will no longer import files under editor directories
FixUE4 Pages developed in Coherent Editor will reload on playing
FixUE4 Fixed a crash in Coherent Editor

Version – released 5 Oct 2015

FeatureUE4 Support for Unreal Engine 4.9.2
FeatureUE4 Added a launcher serving as quick access hub for Coherent GT for UE4 plugin
Feature Added the Coherent Editor in the native Coherent GT
Feature Added a launcher serving as quick access hub for Coherent GT

Version – released 30 Sep 2015

FeatureUE4 Support for Unreal Engine 4.9.1
FixUE4 GTMaterial is compatible with Unreal Engine 4.8
FixUE4 Key modifiers are correctly set for mouse events
APIUE4 Removed obsolete assets

Version – released 14 Sep 2015

Feature Coherent GT now allows clients to control the time in the page
API Added Coherent::UIGT::SystemSettings::ControlTime property which is used for enabling Time control
API Added a new UISystemListener class used for UI system-wide notifications and callbacks
Feature Implemented radial gradient effects
Enhancement Added documentation for the C++ HelloGT sample
Fix Fixed crash with when using canvas in asynchronous mode
Fix Fixed crash when using proxy settings
Fix Layer clipping rectangles take scaling into account
Fix Fixed Elements overlay triggering asserts in the Debugger
FeatureUnity3D Mac OS X support in Unity3D
FeatureUnity3D Coherent View works with post effects in Unity3D
FeatureUE4 Support for Unreal Engine 4.9


Coherent Editor can now be launched from the Coherent GT menu

Version – released 19 Aug 2015

Fix The installer asks for existing project folder only when adding Coherent GT to an existing game

Version – released 18 Aug 2015

Feature GPU accelerated canvas element
Enhancement Added the run-time event name in the COHERENTGT_TRIGGER_EVENT_SCOPE macro
Fix The “ended” event for video elements is correctly emitted
Fix Fixed memory allocation related crash
FeatureUE4 Audio playback in UE4
FeatureUE4 Added a complex game menu sample


Added a new setting for Coherent GT that allows specifying a custom
coui:// resource root, useful for debugging
FixUE4 The “Coherent GT/Add HUD” menu entry is now available if you add a Blueprint Game Mode override in the world settings as well
FixUE4 SCoherentUIGTInputForward correctly traces mouse movements over 3D meshes with scaling/skewing transforms


GT’s installer now better guides at the user during installation as game plugin

Version – released 28 July 2015

FeatureUE4 Added a sample map depicting proper async usage.
Feature SSL connections that have certificate errors now report the error and can be continued or stopped.
Feature Clients can provide their own Certificate Authorities bundle for authenticating SSL connections.
Feature Control over the Garbage Collector
Feature Control over cookies
Enhancement coui protocol can stream video files
Enhancement Removed the samples’ dependency on the D3DX library on Windows. The samples now use precompiled shaders for D3D9.
Enhancement Live views are now supported under async mode.
Enhancement Unlimited growing of state and clip stacks of <canvas> are now reported
Fix Fixed rendering artifacts for videos
Fix Fixed potential memory leak and task handling during uninitialization when using async mode.
Fix Fixed a rendering artifact that can occur when resizing a layer
Fix Rare crash on re-initialization UISystem
API Added View::TriggerEvent and Coherent::UIGT::TriggerEvent overloads for up to 8 arguments.
Enhancement Every TriggerEvent call starts with the
COHERENTGT_TRIGGER_EVENT_SCOPE macro, which can be defined for custom behavior within the TriggerEvent scope.
Enhancement Recording events is now done C++ which improves profiling JavaScript code
API Added View::IsReadyForBindings method, which is a convenient way of checking whether the coherent.js bindings are ready to use
API Added UISystem::EraseAllCookies method which deletes all cookies


Moved Coherent GT assets to the Engine directory
API Deprecated the Software renderer
APIUE4 Non-RHI rendering is now deprecated


The Unreal Engine 4 installer installs the Coherent GT plugin as a game plugin for binary Unreal Engine 4 engine.

Version – released 01 July 2015

Feature Coherent GT Async support – all the CPU work of the library can be moved to a work thread. For additional details please consult the
Enhancement Users can add custom events to the Inspector Timeline
Feature Support for Unreal Engine 4.8.1

Due to a bug in the Unreal Engine 4 project generation, CoUIGTTestFPS does not work with installed binary Unreal Engine 4.8. We are working with the Unreal Engine developers on resolving this.
Enhancement TriggerEvents are visible in the Inspector Timeline
Enhancement Greatly expanded the Performance guide
Enhancement Reduced the JavaScript call from native overhead by ~15%
Enhancement Split the new DirectX 11 backend in a delay-loaded library
Enhancement Added a flag to the LoadURL calls that defines if to use the memory cache during load.
API The View::Layout method has been split in 3 methods for easier profiling. The old method is still available for backwards compatibility and internally calls the 3 new ones in row.
FixUE4 Fixed a bug that caused stale resources to be loaded in Views in during development.
Fix Fixed a rendering bug that caused some shadows to be rendered incorrectly.

Version – released 15 June 2015

FeatureUE4 Coherent GT UMG Widget. Coherent GT Views can be embedded in an UMG widget and Coherent GT and UMG work seamlessly together
FeatureUE4 Coherent GT Editor is now in public beta. Coherent GT comes with a powerful integrated UI editor
Feature New DirectX 11 backend. Improves rendering performance by 20-30%. To enable use the CRDT_Dx11New enum value on
SystemRenderer initialization. The new backend is still in Beta, there might be some effects missing.
Feature Performance audit. Coherent GT can analyse a View and give suggestions on how to improve performance on it.
Enhancement Reduced JavaScript event call overhead x3 for user defined types. It is now much faster to call JS from C++.
Enhancement Improved layer resizing algorithm, saves unneeded texture re-creations.
Enhancement Improved the coherent.js support when working in-browser.
Enhancement Rewritten the memory management of Coherent GT. Improves performance by 10-15%.
Enhancement Improved the dirty-rect algorithm. GT now does less paints.
Fix Fixed a bug in the image cache that caused images to be decoded again and again.
Fix Fixed a regression that caused coherent.js to throw an exception when running in a browser.
Fix Fixed input handling on elements with perspective 3D transforms.

Version – released 13 May 2015

Feature Live Views (Picture-in-picture). You can have content rendered by the 3D engine directly in the UI.
Feature Perspective CSS3 transforms. Allows adding pseudo-3D elements in the page.
Feature CSS3 Image Filters. Layers can now have post effects applied to them (blurs, shadows, color filters).
Feature Implemented performance warnings. Warnings fire when a certain threshold is reached and warn the allow developers to notice eventual performance regressions much sooner.
Feature Default rendering for most controls.
Feature Texture cache control. Developers now have control over the size of the texture cache and can check how full it is.
Enhancement Added Mac OS X support.
Enhancement Added binding of properties with const reference setters.
Enhancement Reworked JavaScript garbage collection; JS now uses much less memory.
API Added a new parameter to the OnNavigateTo method that tells if the navigation is happening to the main frame.
Fix Fixed in-memory cache – it was never re-enabled after system un-initialization and thus caused textures not to be reused.
Fix Fixed clipping of layers. Some layers were not working correctly as clips of their descendants.
Fix Fixed a bug that caused Canvas contents to be copied in always new fresh textures.
Fix Added layer size clamping.
Fix Fixed a crash in layers due to a missing reference.

Version – released 10 Mar 2015

Fix Fixed layer clipping and re-draw when compositing is enabled.
Fix Fixed a DirectX 11 state caching bug that caused too many blend states to be created.

Version – released 06 Mar 2015

Feature Accelerated compositing – allows for very fast updates of layers and reduces painting.
Feature CSS3 Transforms allow to have 3D elements in your UI
Feature CSS3 Animations allow to animate the UI with declarative CSS syntax
FeatureUE4 Support for Unreal Engine 4.7.2
Enhancement Asynchronous click-though for DirectX 9
Fix Fixed crash when binding large structures to JavaScript
Fix Fixed crash when using the JavaScript bindings before they are initialized
Fix Renamed the Coherent::MemoryManagement namespace to

Version – released 02 Mar 2015

FeatureUE4 Added a custom blueprint node that allows triggering JavaScript events only within that node.
FeatureUE4 Support for Unreal Engine 4.7

Version – released 18 Feb 2015

FeatureUE4 New RHI renderer! The new renderer increases performance by 25-40% and is fully integrated in the UE4 pipeline.
FeatureUE4 HTML assets are now imported into UE4’s content browser. All UI resources are visible in the UE4 Content Browser window.
FeatureUE4 New UE4 Editor menu allows easy setup of Coherent GT HUDs and in-world UIs. You can now add a GT HUD or in-world interface with just one click.


Decreased the overhead of calls from UE4 to JavaScript 4-5x. Remember to update your coherent.js file with the new one to take advantage of the speed-up.


Click-through implementation now never causes GPU-CPU stalls.


Updated and greatly expanded the documentation. Added Workflow and Performance guides.


The GT installer now bundles ready-made Blueprints and objects for easier integration in projects.


Coherent GT for Unreal now supports Shader Model 4-capable video cards.
APIUE4 Added support for click-through control through Blueprints.
FixUE4 Fixed a crash with the RHI renderer when the mouse is on the right or bottom edge of the screen.
FixUE4 Fixed a bug in the RHI renderer that caused rare artifacts due to wrong start index.

Version – released 27 Jan 2015

Feature Input method editor (IME) support for East Asian languages. Coherent UI GT now supports all aspects of editing and displaying languages like Chinese, Japanese, Korean.
Feature External memory management support. Users can now specify routines for memory allocation and deallocation and strictly control the memory usage of Coherent GT.
Enhancement Removed some third-party dependencies. The overall size of the SDK is reduced as well as the libraries count.
Enhancement Reduced memory footprint.
Enhancement Improved overall performance by removing some unnecessary software layer re-sizes.
Enhancement On Windows True-Type font collections are loaded along with standalone fonts.
FeatureUE4 Fully functional RHI-based renderer. The new renderer greatly improves Draw thread performance. The RHI renderer is still disabled by default. Please consult the documentation on how to enable it.


Numerous fixes and improvements in the RHI renderer across all platforms.
FixUE4 Fixed a rare crash on system destruction.

Version – released 08 Jan 2015

Feature Memory Management API
Feature Disk Cache API
Feature WebSocket support

Version – released 20 Dec 2014

API Added new API method OnTextInputTypeChanged for easier IME integration
API Renamed InitializeUISystem to InitializeUIGTSystem so that it doesn’t clash with Coherent UI 1.x
API Removed all wchar_t* types from the public API. All methods now work consistently with UTF8 strings. Affected methods: OnFinishLoad, OnFailLoad, OnStartLoading, OnNavigateTo
API Renamed the Logging namespace to LoggingGT for easier side-by-side work with Coherent UI 1.x/2.x
API Renamed ResourceRequestBase and ResourceResponse to ResourceRequestUIGT and ResourceResponseUIGT
Enhancement Unified all font rendering across supported platforms
Enhancement Better texture caching. Less texture memory will be used.
Enhancement Added workflow documentation guide, located in the “Documentation” folder of the SDK.
Enhancement Added a performance testing client in the Coherent GT SDK, located in the “GTPlayer” folder
Enhancement Added a chapter for best practices in the documentation
Fix Removed a possible debug-break in all builds related to the SSL number generator
FeatureUE4 Support for Unreal Engine 4.6.1
FeatureUE4 Coherent GT plugin is an engine plugin


Unified all font rendering across supported platforms


Better texture caching. Less texture memory will be used.


Added workflow documentation guide, located in the “Documentation” folder of the SDK.


Added a chapter for best practices in the documentation
APIUE4 Added new API method OnTextInputTypeChanged for easier IME integration
FixUE4 Removed a possible debug-break in all builds related to the SSL number generator

Version – released 03 Dec 2014

Feature Video support through WebM and VP8/VP9
Feature Audio support through Vorbis
Feature Resource request headers are now accessible from the Resource Handler
Enhancement Substantially improved the scaling performance during animations
FeatureUE4 Support for Unreal Engine 4.6


Simplified input handling
APIUE4 Added SCoherentUIGTInputForward::SetPropagateKeyboardEvents, which allows controlling whether keyboard events are consumed or propagated to other widgets when the input forwarder has keyboard focus.
APIUE4 Changed
ACoherentUIGTInputActor::AllowJoystickInputWhileUIIsFocused to
ACoherentUIGTInputActor::AllowJoystickInputWhileUIIsFocused is now deprecated. The new method allows specifying not only joystick events propagation, but keyboard ones as well.
APIUE4 Changed
ACoherentUIGTInputActor::IsJoystickInputWhileUIIsFocusedAllowed to
ACoherentUIGTInputActor::IsJoystickInputWhileUIIsFocusedAllowed is now deprecated.


Removed code from sample for deprecated input component binder. Only the input forwarding widget (SCoherentUIGTInputForward) and its wrapper (ACoherentUIGTInputActor) are used for input now.

Version – released 22 Nov 2014

Fix Fixed crash when exporting empty arrays and maps to JavaScript
Feature Added Binder::PeekValueType to allow more dynamic binding
Enhancement Moved initial script execution after engine has been initialized
Feature Expose API for setting proxy settings
FeatureUE4 Evaluation version of Coherent GT


Improved performance when using scaling
FixUE4 Name clashes between Coherent UI and Coherent GT plugins


coui:// handler supports URLs with query and fragments


Improved installer
FixUE4 Crash when running multiple clients in a single process
FeatureUE4 Added support for Unreal Engine 4.5.0
FeatureUE4 Moved UIResources folder to CoUITestFPS/Contents so UI resources can be automatically packaged.