Release notes



Released 09 Apr 2019
FeatureAdded support for CSS transitions
FeatureAdded support for pointer-events CSS property
FeatureEnhanced the flex CSS property to support setting grow and shrink
FeatureAdded support for CSS cursors
FeatureAdded support for the console tab and script debugging on Mac OS X
FeatureAdded support for mix-blend-mode: add
FeatureAdded support for KeyboardEvent.location
FeatureAdded support for copy and paste
FeatureAdded support for Home and End keys
FeatureAdded automatic sizing for text fields
FeatureAdded API to get the Nodes attributes from cohtml::INodeProxy
FeatureAdded text selection to all elements
EnhancementRefactored Renoir backend API to work better with low-level rendering APIs like Metal
EnhancementReplaced JavaScriptCore with ChakraCore on Xbox One and PlayStation 4
EnhancementReplaced JavaScriptCore with V8 on Mac OS X
EnhancementThe inspector no longer disconnects when the view is reloaded
EnhancementSignificantly improved inspector loading speed for pages with lots of elements
EnhancementData-binding attributes are visible in the inspector
EnhancementReduced thread-local variables count to allow running on more Android devices
EnhancementAndroid uses the Android NDK r15b
EnhancementAdded gestures support in Unity3D
EnhancementAdded range requests support in Unity3D
EnhancementAdded gamepad support to PlayStation4 samples
EnhancementImproved performance for drawing polylines in canvas
EnhancementAllowed loading stylesheets encoded in UTF-8 with BOM
EnhancementMoved V8 background tasks to worker threads tasks
EnhancementAdded GPU debug metadata in Unreal Engine 4
EnhancementImplemented animation shorthand CSS property
EnhancementAdded custom HTMLMediaElement events signaling when a decoder cannot keep up (cohplaybackstalled) and when it catches up (cohplaybackresumed). These events can be used to synchronize other animations with the video playback.
EnhancementSeeking paused videos now shows a preview of the seeked position
EnhancementAdded non-standard property to the CanvasRenderingContext2D “enableFastLineSegmentDrawing” which can allows much faster drawing in a canvas if the image consists of line segments only
FixFixed assert when calling bound C++ methods with incorrect arguments from JavaScript
FixFixed assert when removing the src attribute of an img and reloading the view
FixFixed using the skewX property in animations
FixFixed leaking some GPU resources on reloading the view
FixFixed calling the connectedCallback on custom elements in appendChild
FixFixed calling bound methods on objects that have been removed with View::DestroyExposedInstance
FixFixed using unsigned numbers for specifying a color in data-binding
FixFixed possible memory leak of ParseHTML when the system is destroyed before the load has finished.
FixFixed crash when using canvas stroke with gradient
FixFixed Inspector to show all transformations on an element with multiple transformations.
FixFixed currentTime attribute when the animation is paused
FixFixed onBlur, onFocus events on input elements when using React
APIChanged Renoir API to allow simultaneous usage from Coherent GT and Gameface
APISplit Renoir backend in UnrealEngine 4 to a separate module
APIAdded virtual destructors to pure virtual classes and structs
APIAdded default implementation to ViewListener’s methods
APIRenamed Renoir library files to start with lib
APIMoved enable color writes to the PSO instead of SetRenderTarget param. This is part of a breaking change in Renoir backends. For more information, see the migration guide
APIMoved MSAA to the PSO. This is part of a breaking change in Renoir backends. For more information, see the migration guide
APIAdded upload buffer (constant buffers) management in Renoir. This is part of a breaking change in Renoir backends. For more information, see the migration guide
APIMoved auxiliary constant buffers from the Renoir backend to Renoir core library. This is part of a breaking change in Renoir backends. For more information, see the migration guide
APIStarted doing ClearQuad instead of ClearRenderTarget based on new backend capability. This is part of a breaking change in Renoir backends. For more information, see the migration guide
APIAdded BeginRenderPass and EndRenderPass backend commands to Renoir. This is part of a breaking change in Renoir backends. For more information, see the migration guide


Released 24 Apr 2019
FeatureUpdated Unreal Engine to 4.22
FixFixed crash when using View::UnloadDocument
FixFixed support for React v16.5
FixFixed using iterator names that are prefix of other iterator namesin data-binding
FixFixed using {{model}} in data-binding expressions for C++ models.
FixFixed indexOf and slice for arrays exposed by-ref on ChakraCoreplatforms


Released 13 May 2019
FeatureAdded the :active pseudo selector
FeatureAdded the visibility CSS property
FeatureAdded the KeyboardEvent.repeat property
EnhancementAdded data-bind-html, which allows to set innerHTML with data-binding
EnhancementAllowed the localization texts to contain html tags
EnhancementAdded the load event to script and stylesheet elements
EnhancementEnhanced log messages for wrong property names used for data-binding
Enhancementmodel}} (without property) can be used for data-binding
EnhancementScrolling works correctly with nested scrollable elements
EnhancementAutomatically casting enum types to int for iOS and Switch for binding
EnhancementBinding supports long numbers
EnhancementRegular on event handlers work with data-bind-for
EnhancementNot handled promise rejections are logged
EnhancementAdded engine.unregisterModel API to unregister a model from JavaScript
EnhancementAdded an API to set the ILocalizationManager in Unreal Engine 4 integration
EnhancementAdded support for exposing UDataTable to JavaScript
EnhancementAdded ability to customize the automatic binding in Unreal Engine 4
FixFixed disappearing SVG images when background-image property is changed
FixPositioning of text caret in text inputs with aligment
FixFixed text selection when text has CSS transform
FixFixed crash in Unreal Engine 4 when chaining multiple property accesses in data-binding
FixFixed the gamepaddisconnected event to contain which gamepad has been disconnected
FixFixed cloneNode to clone attached event listeners


Released 24 Jun 2019
FixFixed crash when using by-value getters in data-binding
FixFixed crash when recreating views on PlayStation 4
FixFixed missing text on the UMG widget on PlayStation 4
FixFixed broken gradients on the UMG widget on PlayStation 4
FixFixed rendering uninitialized textures with the UMG widget on Xbox One

Migration guide

This section outlines the changes you need to apply in order to upgrade from Prysm versions 1.1 and prior to 1.2 and later.

The current backend API was designed around DirectX 11 and therefore implementing a DirectX 11 backend with the current API is simple and intuitive. However, with the advent of modern low-level APIs (e.g. Dx12, Metal and Vulkan) and concepts such as render passes, enhancements of the backend API were needed, so that the backend implementation for those graphics APIs is easier and more efficient.

You can read more about the motivation for the backend API changes here.

In Prysm 1.2, Renoir’s backend API has been modified significantly with the introduction of 2 new commands, 4 new Renoir Core capabilities and one new shader type. There are also several changes in the graphics backend that must be adapted from previous versions for the new version to work.

If you prefer to make minimal changes to your backend and not use the new capabilities, here are the steps for migrating:

  • Add the following lines to the FillCaps method
outCaps.ShouldUseRenderPasses = false;
outCaps.ShouldClearRTWithClearQuad = false;
outCaps.ConstantBufferBlocksCount = 1;
outCaps.ConstantBufferRingSize = 1;
outCaps.ShaderMapping[ST_ClearQuad] = ST_ClearQuad;
  • Add unsigned size as last argument of the CreateConstantBuffer method and use it for the constant buffer allocation size. This is how the CreateConstantBuffer method declaration in the backend header should look like:
virtual bool CreateConstantBuffer(CBType type, ConstantBufferObject object, unsigned size) override;

Example of using the size parameter on constant buffer creation from the DirectX11 backend:

bool Dx11Backend::CreateConstantBuffer(CBType, ConstantBufferObject object, unsigned size)
    D3D11_BUFFER_DESC bufferDesc;
    bufferDesc.ByteWidth = size;
    // Create the constant buffer with the filled buffer description
    m_Device->CreateBuffer(&bufferDesc, ..)
  • In SetRenderTarget stop using EnableColorWrites flag, as it is no longer present and instead handle the PipelineState's ColorMask field in CreatePipelineState. This field currently only supports the values ColorWriteMask:CWM_None and ColorWriteMask::CWM_All, which correspond to the previous false and true values of EnableColorWrites. Set the appropriate value of the graphics API’s render target color write mask. E.g. in DirectX11 the write mask is placed in the description of the blend state:
bool Dx11Backend::CreatePipelineState(const PipelineState& state, PipelineStateObject object)
    D3D11_BLEND_DESC desc;
    desc.RenderTarget[0].RenderTargetWriteMask = UINT8(state.ColorMask);
    // Create the blend state with the filled description
    m_Device->CreateBlendState(&desc, ...)
  • In ExecuteRendering add empty cases with only a break statement in them for BC_BeginRenderPass and BC_EndRenderPass:
case BC_BeginRenderPass:
case BC_EndRenderPass:

The MSAASamples field was added to the PipelineState structure, so you may start using it in CreatePipelineState.

Below we will describe each new capability, how it can affect your backend, and what the needed changes you need to make to use it are.

When the ShouldUseRenderPasses capability is enabled, Renoir will start enqueuing the commands BeginRenderPass and EndRenderPass and stop issuing the SetRenderTarget and ResolveRenderTarget commands. The BeginRenderPass command provides all the needed information for starting a render pass in modern graphics APIs like Metal and Vulkan. This information includes the render targets, whether they should be cleared on a render pass load, and if they should be resolved on store. Here are the additional steps you need to make to start using this capability:

  • Set ShouldUseRenderPasses to true in the FillCaps method
  • You can remove the implementation of the SetRenderTarget and ResolveRenderTarget methods and add an assert that they are never called
  • Implement a BeginRenderPass method, which will handle the corresponding command by using the provided information by it to begin a render pass in the graphics API
  • Implement an EndRenderPass method, which will handle the corresponding command by ending the current render pass, and possibly also reset any currently kept state of the render pass. E.g. in our Metal backend, the implementation of the EndRenderPass method is the following:
[m_State->CurrentCmdEncoder endEncoding];

m_State->CurrentCmdEncoder = nil; m_State->BoundGPUState = GPUState();

Enabling the ShouldClearRTWithClearQuad capability will make Renoir issue a fullscreen clear quad, instead of calling ClearRenderTarget. The clear quad is done through a new vertex and pixel shader. The capability was added so that we don’t need to create a new render pass to clear a render target in graphics APIs like Metal, which does not provide an easier way to do it. Here are the additional steps you need to make to start using this capability:

  • Set ShouldClearRTWithClearQuad to true in the FillCaps method
  • You can remove the implementation of the ClearRenderTarget method and add an assert that it is never called
  • You need to create a new ST_ClearQuad vertex and pixel shader, compile them if necessary and start using them. You can check out the example ST_ClearQuad HLSL shaders provided with the DirectX11 backend. The Metal backend is using the clear quad capability, so you can check out how to use the new shaders in its implementation.

The ConstantBufferRingSize capability allows you to set the size of the internal ring buffer, which is used to manage Renoir’s constant buffers. We recommend setting this size to 4 for low-level graphics APIs like Dx12, Metal and Vulkan. The motivation for this particular size is that the maximum count of buffered frames in a standard pipeline is 3, and in order to surely avoid an overlap of constant buffers, they should be managed by a circular buffer with size 4. If you have a pipeline with a higher maximum count of buffered frames, then this value should be changed accordingly. For most high-level graphics APIs, the ring buffer size should be set to 1, because the drivers for them handle constant buffer overlap internally, and therefore a greater value for the ring buffer size is unnecessary.

The only steps you need to make to start using this capability are:

  • Set ConstantBufferRingSize to the appropriate value in the FillCaps method
  • If you have a ring buffer for the constant buffers in your backend, then you can remove it, because Renoir will do it automatically for you

The ConstantBufferBlocksCount capability allows you to set the count of aligned constant buffer blocks for each constant buffer type. Renoir will issue a CreateConstantBuffer call with a size equal to (constant buffer blocks count) * (aligned specific constant buffer size) for each constant buffer type. If the blocks count value is greater than 1, then if the regular constant buffer becomes full, Renoir will make sure that a new auxiliary constant buffer is allocated. If the blocks count value is equal to 1, then Renoir won’t create any auxiliary constant buffers. Auxiliary constant buffers are allocated per frame, thus being allocated before ExecuteRendering is called and deallocated immediately after that. Setting constant buffer ring size and blocks count value to greater than 1 usually goes hand in hand, because both provide functionality that otherwise should be explicitly implemented in the backend for low-level graphics APIs like Dx12, Metal and Vulkan. For other APIs that don’t support constant buffers, but use uniform slots (e.g OpenGL) both capabilities should be set to 1 to avoid unnecessary constant buffer creation.

The only steps you need to make, so you can start using this capability are:

  • Set ConstantBufferBlocksCount to the appropriate value in the FillCaps method
  • Remove all the logic in your backend, which manually creates auxiliary buffers once the regular ones are full. Renoir will create and manage them automatically