Fuse 1.6.1

This is a bug fix release, with the following fixes:

UX Compiler
  • Fixed a bug introduced in 1.6 that caused E0000: The given key was not present in the dictionary. errors to be generated for some UX document roots.
  • Restore accidentally broken NativeEvent.RaiseAsync() API.
  • Rolled back NativeProperty constructor API to the pre-1.6 state. Code updated to 1.6 needs to be rolled back as well.
  • Previous changes resulted in a breaking change we would rather avoid so we reintroduce Invoke(Action ..) so we can take it through the usual deprecation cycle.

Download this version

Fuse 1.6.0


  • The new JavaScript programming model is finally available!
    • It's still in BETA so here be dragons. Make sure to read the docs carefully! (But something as exciting as this is worth the risk of a few dragons)
  • More features supported in the stand-alone Fuse Preview app. (We kinda forgot them last time.... Sorry about that!)
  • A metric ton (according to our measurements) of updates & bugfixes in Fuselibs.
Fuse Preview app
  • Fuse.Camera, Fuse.CameraRoll, Fuse.Sound and Fuse.LocalNotifications are now supported in the app available on the iOS app store and Google Play.
  • Support for the new FuseJS features will be added once the rest of this release has gone through the QA phase.
  • A new model for structuring your apps which should make development (and testing!) much nicer.
  • ES6 support through transpiling so that you can write modern JS
  • Automatic change detection (e.g. you can choose to not use Observables)
  • But keep in mind that this is still in beta and things may change so read the docs carefully
  • Fixed issue where <Image /> inside a <NativeViewHost /> on android could display incorrectly
  • Fixed bug where ScrollView's inside a NativeViewHost would scroll to fast
  • Fixed bug where the scrolling indicator in a native ScrollView would not show on iOS
  • Added ContentSize property on the Fuse.Controls.Native.IScrollViewHost interface. Needed by iOS to layout the native scrollview correctly
  • Introduced an experimental Let feature that allows creating expression aliases and local variables in UX
  • Added specific type version of Let, such as LetFloat and LetString. This improve the ability to connect pieces of the UX together and do animation/transitions in UX without using JavaScript.
  • Improved the internals of Instantiator (the base for Each and Instance). This also fixed a few corner cases with templates not updating, but should otherwise not affect user code.
  • Fixed the creation of templates in Each / Instance when the data context is null/non-extant. It will now not instantiate the templates are all. This prevents some kinds of binding defects and improves efficiency with default templates.
  • Fixed an incorrect cascade of MinWidth / MinHeight. This could only be noticed in certain scenarios using BoxSizing="FillAspect".
  • Fixed the width, height, x, and y functions to support an element losing its layout. They become undefined in this case, thus allowing a syntax like width(element) ?? 50
  • Fixed the invalid propagation of MaxWidth/MaxHeight in a StackPanel to its children
Data Context
  • Resolved a situation with nested context binding {}, such as With and Instance, where the data would not correctly update
  • Fixed the ordering of events so that SelectionChanged is emitted after the bound value is updated
  • Deprecated UnaryOperator.OnNewOperand and OnLostOperand. These are part of a broken pattern of using unary expressions (and were not present on Binary/Ternary/QuaternaryOperator). You generally shouldn't need this, and should implement Compute instead. In the rare cases you need the virtuals you'll need to extend Expression and implement Subscribe, using ExpressionListener as a way to capture the correct functionality.
  • Moved VarArgFunction.Argument to Expression.Argument. It's in a base class so still has visibility in VarArgFunction.
  • VarArgFunction.Subscription.OnNewData and OnLostData have been sealed. They should not have been open for overriding before as it conflicts with the inner workings on the class. Only the OnNewPartialArguments and OnNewArguments should be overridden.
  • Improved error handling on several operators and math functions. Instead of exceptions these should produce the standard conversion/computation warnings for invalid types.
  • Added size() function to force conversion to a Size or Size2 type. Useful when dealing with unknown types and some operators that would otherwise result in the undesired conversion.
  • Fixed an issue with Navigator.Pages not registering pages correctly in certain initialization orders
  • Added $navigationRequest to Navigation.Pages objects. This can be used to fine-tune the navigation.
  • Added Instance.Item to work similar to an Each with a single data item
Expression Functions
  • Added nonNull for special evaluation handling for temporary null values. This may be useful in migrating code that is now producing many incompatible argument warnings.
  • Changed operators / functions to report warnings if they are provided with invalid arguments. This should help locate errors in code that were previously silent and just didn't evaluate, or evaluated wrong. Consider using the ?? operator, and the isNull, isDefined and nonNull functions to deal with non-data scenarios.
  • Removed protected from BinaryOperator.OnNewOperands. This was intended to be internal as there is no correct way to overload it. If you happened to use it we can provide a different base-class to use for you.
Fuse.Preview Selection
  • Removed the following APIs, that were never meant to be exposed to user-code:
    • Fuse.Visual.DrawLocalSelection(DrawContext, Rect)
    • Fuse.Visual.DrawSelection(DrawContext)
    • Fuse.AppBase.InvalidateSelection()
    • Fuse.App.DrawSelection(DrawContext)
    • Fuse.Preview.SelectionManager
    • Fuse.Preview.ISelection
  • Added float() expression to force conversion to float values
  • Added string() expression to force conversion to string values
  • Fixed issue where creating a repeating Timer with 0 delay in JavaScript would not prevent the worker thread to become idle.
  • RangeControl.Value and RangeControl2D.Value are not longer clamped to the Range of the control. This fixes issues where the Value was incorrectly modified when the range and value were both data bound. The user behaviors LinearRangeBehavior and CircularRangeBehavior will both however clamp to the range -- the user cannot select outside the range.
Observables and bindings
  • Fixed an issue where missing data was propagated as null. This will affect Observable's that contain zero data, and may have resulted in some bindings showing old/incorrect data.
Multi-density image sources
  • Fixed an issue where the desired size of a multi-density source ended up as the pixel size of the selected image source. The effect was that images rendered on a high-density screen, would appear larger than on a low density screen.
  • Fixed an issue where PlayMode="Wrap" would not loop if the duration was less than 1 second
  • Added isDefined to check if a value is known in the context
  • Added isNull to check if a value is null or doesn't exist
  • Added object support to Router script functions, such as goto, push, bookmark, etc. This mirrors the upcoming Model ability to use objects as path elements.
  • Added object support to Modify/Push/GotoRoute actions.
  • Added NavigationControl.modifyPath to the JavaScript interface. This allows extended local path manipulation without using a router.
  • Fixed iOS issue where the return key would display "next" instead of "return".
  • Navigator blocks input to pages while transitioning to new pages. To get the old behaviour, where input is not blocked, set <Navigator BlockInput="Never">.
  • Added OnLostData to the IListener interface. This is needed to properly deal with changes in context in Preview, Model, and some JavaScript situations.
  • Added OnLostData to the InnerListener class. Implementations should deal with this scenario.
  • Changed null coalesce ?? to use the default when the left operand doesn't exist, not just when it's null
  • ToDouble replaced with TryToDouble for naming consistency (old names remain as deprecated)
  • Fixed a bug where IsFrozen would ignore Panel.Opacity.
  • Fixed an Uno reflection bug that caused these pickers to crash in preview.
  • Fuse.Scripting's Function type has a Call method, this now takes a Scripting.Context. This guarantees that it can only occur on the VM thread.
  • Fuse.Scripting's Object type has a CallMethod method, this now takes a Scripting.Context. This guarantees that it can only occur on the VM thread.
  • IMirror is no longer implemented by ThreadWorker. This functionality has been moved to the context
  • Moved ArrayMirror, ClassInstance, ModuleInstance, ObjectMirror, Observable, ObservableProperty, RootableScriptModule & ThreadWorker to the Fuse.Scripting.JavaScript namespace
  • Removed the CanEvaluate method and instead rely on the passing of the Scripting.Context to know if we are on the VM thread or not.
  • The 'wrapping' functionality has been moved from the ThreadWorker to a standalone static class called TypeWrapper. The IThreadWorker no longer provides Wrap & UnWrap
  • ThreadWorker.ScriptClass functionality moved to context. We will likely want to factor this out to a helper class however for now the major benefit is that ThreadWorker no longer owns these features.
  • Remove the public Context property from the ThreadWorker. Sadly the context is still available via the internal field so that the tests can work. This will need to be fixed.
  • Fuse.Reactive now depends on Fuse.Scripting so that it can talk about the Scripting.Context in it's provided interfaces.
  • DateTimeConverterHelpers moved to its own uno file.
  • IMirror's Reflect now takes a Scripting.Context
  • IThreadWorker no longer implement IDispatcher
  • Fuse.Scripting.JavaScript's ThreadWorker no longer blocks on construction
  • Implemented console.error, console.warn and console.info
  • Improved formatting for the above functions, as well as for console.log
  • The ScriptMethod<T> constructor now throws if it's passed ExecutionThread.MainThread with Func, instead of failing to run it later on.
  • The ScriptMethodInline constructor that takes an ExecutionThread as an argument is now obsolete. Use the one without instead. JavaScript needs to run on the JavaScript thread anyway.
  • The ScriptMethod<T> constructor that takes Func and ExecutionThread as arguments is now obsolete. Use the one without instead.
  • Calling script-methods that doesn't take any arguments should now consistently give an error. This was already the case for many functions. This is intended to ensure user-code is forward-compatible.
  • ScriptException.ErrorMessage has been marked as obsolete, use ScriptException.Message instead.
  • ScriptException.Message no longer includes all details about the script-exception, only the message itself. If you want the extra information, use ScriptException.ToString(), or check the specific fields.
  • Fuse.IScriptException has been marked as obsolete. This was previously unused.
  • ScriptException.JSStackTrace has been marked as obsolete, use ScriptException.ScriptStackTrace instead.
  • ScriptException.SourceLine has been marked as obsolete, and consistently returns null now. The latter was always the case except for when using V8 before. The same information can be deduced from the project files and FileName + LineNumber fields.
  • ModuleResult.Object has been marked as obsolete. Use ModuleResult.GetObject(Context) instead.
  • ModuleResult.Exports has been marked as obsolete. Use ModuleResult.GetExports(Context) instead.
  • Function.Call, Function.Construct, Object.InstanceOf and Object.CallMethod now takes a Context as their first argument. The old signatures has been marked as obsolete.
JavaScript: JavaScriptCore on Android
  • Added support for JavaScriptCore on Android. Build with -DUSE_JAVASCRIPTCORE to enable it on Android. JavaScriptCore is by default enabled on iOS.
Environment variables

The following environment variables can be used to configure Uno globally, potentially useful in CI environments: - LOG_LEVEL=<0..3> - Set verbosity level (default = 0) - LOG_TRACE=1 - Print exception stack traces where available - DEBUG_GL=1 - Enable the OpenGL debug layer in .NET builds

Android build target
  • Added the following build properties for requiring gradle repositories via UXL:
    • Gradle.BuildScript.Repository
    • Gradle.AllProjects.Repository
Project files
  • Support for iPhone 20pt 2x and 3x icons has been added. This can be customized using the iOS.Icons.iPhone_20_2x and iOS.Icons.iPhone_20_3x project-setting, respectively.
  • Support for iPad 20pt 1x and 2x icons has been added. This can be customized using the iOS.Icons.iPad_20_1x and iOS.Icons.iPad_20_2x project-setting, respectively.
  • Support for iPad Pro icons has been added. This can be customized using the iOS.Icons.iPad_83.5_2x project-setting.
  • Support for iOS Marketing icons has been added. This can be customized using the iOS.Icons.iOS-Marketing_1024_1x project-setting.
  • Support for iPhoneX Launch Image has been added. This can be customized using the iOS.LaunchImages.iPhone_Portrait_iPhoneX_3x and iOS.LaunchImages.iPhone_Landscape_iPhoneX_3x project-setting.
Command-line interface
  • The following old commands were removed from the release: cp, disasm, mkdir.
.NET backend
  • Set DEBUG_GL=1 in your environment to enable the OpenGL debug layer at run-time. This is available in .NET builds on macOS and Windows.
  • Fixed regression on iOS where, because we had implemented the methods for pushnotifications apps were rejected from the app store for not requiring notifications even if they didnt use the notification's feature
Long path? Long code.

We can now extract zip files containing long filenames (255+ characters) on Windows. This should enable us to do things like providing Node.js on-demand in the future.

  • Fixed issue where photos captured in landscape on iOS did not contain correct EXIF data for rotation
  • Fixed issue where photos captured on Android could end up with incorrect rotation in its EXIF data
  • Made all Futures in the CameraView uno API resolve or reject on the UI thread instead of it being undefined. One would never not use this API from the UI thread anyways.
  • Changed iOS to request permission to use microphone when capture mode is set to video.
  • Made saving photos on Android async. Before this would block the JS or UI thread
  • Fixed issue where user set picture size could be reset on some android devices
  • Fixed aspect ration mismatch issue between preview and photo captured when using user specified picture size
  • Fixed issue where setting a PreviewStretchMode could end up stretching incorrectly
  • Fixed issue where the live preview's aspect ratio did not match captured photos
  • Fixed issue where the Camera hardware resources were not released if the app enters background
Fuse Studio
  • Fixed an issue where in certain situations starting local preview of a project that was already open in Fuse would open a new Fuse window, rather than just focusing the existing window

Download this version

Fuse 1.5.0


  • Brand new stand-alone preview app!
  • Fuse Studio now much faster & snappier with larger app projects
Tool updates
  • Stand-alone preview app which means you can preview (most) projects without needing Xcode or the Android SDK/NDK!
  • Improved performance of Fuse Studio, especially when working with larger projects
  • Fixed an issue where double clicking the Fuse tray icon on Windows would show an error message "Unable to create Fuse document client. Please try again."
  • Fixed an issue where the building indicator bar would not show when you opened a project
  • Clicking the "Build failed" and "Auto reload failed" indicator bars now opens the log view
  • Fixed an issue on macOS where UnoHost processes were left running if Fuse crashed
  • Fuse now prints information about OpenGL version when local preview starts, and gives an error message if the version is lower than 2.1
  • Added tool tips to several label-less inspector editors
  • Show busy indicator as a notification bar if building or reifying takes more than 250ms
Library updates
  • Premium libs: Fixed issue where older iOS devices would fail to capture photos after CameraView.PhotoCaptureImageSource has been used once to display a captured photo.
  • Fixed a defect in NodeGroup that would cause some nodes to be inserted in the wrong order, in particular if using combinations of Each, With, triggers, and Defer.
  • Fixed an issue where toUpper and toLower would crash on null intput. Now they propagate null instead.
  • Fixed an issue where some properties (for example TimePicker.Is24HourView) wouldn't work when set from UX.
  • Fixed a documentation issue with TimePicker where the code example used the wrong name for the Is24HourView property.

Download this version

Fuse 1.4.0


  • Native date and time pickers on Android and iOS
  • All new Fuse dashboard
  • Images that have associated Exif data will automatically be rotated
  • Added Restart to the Viewport menu to reset all state in your app
  • Fixed several issues with the installers for Android tools and Sublime plugin


  • Introduced Fuse.Controls.DatePicker class, which wraps native date pickers on Android and iOS. See the DatePicker class documentation for more details.
  • Introduced Fuse.Controls.TimePicker class, which wraps native time pickers on Android and iOS. See the TimePicker class documentation for more details.
  • Images that have associated Exif data with the orientation tag will automatically be rotated so that they are displayed in the correct orientation
Pro feature: CameraView
  • The CameraView API has been replaced by a new and revamped version
  • Promised based JS API that can fail gracefully. Makes for a much better experience both in production and while coding in preview
  • Introducing <CameraView.CapturePhotoImageSource /> and <CameraView.PhotoLoaded /> . An ImageSource that can be used to display instant preview when you capture a photo. The CameraView.PhotoLoaded trigger will fire whenever a preview of a captured photo is ready.
  • This is a breaking change. The previous implementation will not be supported. For the time being you can find the previous implementation in Fuse.Deprecated.CameraView but we strongly advise you to migrate to the new implementation.
  • Please check the updated documentation and the example app for reference.
  • Known issue: If you use CameraView.PhotoCaptureImageSource on iPhone 6 and older you will only be able to capture one photo - additional attempts will fail with an error. This will be fixed in the next release.
  • Fixed issue on android where placeholder text on a <TextInput IsPassword="true" /> would be drawn as password dots
  • Invoke now takes an Action<Scripting.Context>. This is the first step in refactoring our scripting layer to make sure code does not evaluate JS on the wrong thread
  • The Observable property has been removed from Context & IThreadWorker
  • Fuse.Reactive.JavaScript has been renamed to Fuse.Scripting.JavaScript & the separate VM packages are now subdirectories of this package
DesktopApp Updates
  • Fixed an issue about certain event not triggering a proper update and redraw on desktop preview/build
  • LinearRangeBehavior now correctly responds to UserStep values, providing quantized input
  • Fixed RangeControl.RelativeValue to properly update when bound in UX
  • Allowed Minimum to be less than Maximum on RangeControl making it easier to do left-to-right 100..0 ranges.
  • Fixed a defect in position calculations in LinearRangeBehavior. It now uses the immediate Element parent for bounds calculation as opposed to the RangeControl.
  • Added UserStep support to Android and iOS native Slider
  • Exported the methods goBack, goForward, reload and stop for use in FuseJS
  • Fixed regression in 1.3 that broke WebView when using URISchemeHandler
  • Fixed a NullReferenceError that could happen while using ScrollViewPager in preview
  • Fixed bug on Android where setting TextWrapping="NoWrap" would force the TextView to be single line. New behavior is to instead allow the view to scroll horizontally instead of automatically wrapping the text.
  • Added native support, meaning it can be used by images inside a NativeViewHost.
  • Fixed bug in Video where playback actions, like Play, used before the video was initialized would end up getting swallowed.
  • Added some JavaScript methods to Video to make it easier to control playback from JavaScript, as well as obtaining information the video duration.
  • Made Video.Duration and Video.Position property-bindable.
  • Fixed a bug where UX expressions that produce two component floats did not expand to four compoent floats the same same way as literals did.
Fuse.Reactive framework changes (Uno-level)
  • These are breaking changes, but very unlikely to affect your app:
    • The DataBinding, EventBinding and ExpressionBinding class constructors no longer take a NameTable argument.
    • The Name and This expression classes has been removed. The UX compiler will now compile these as Constant expressions that contain the actual objects instead.
    • The IContext interface no longer contains the NameTable property.
    • The Fuse.IRaw interface removed (now internal to the Fuse.Reactive.JavaScript package). Had no practical public use.
    • The Fuse.Reactive.ListMirror class is no longer public. This was never intended to be public and has no practical public application.
    • Added detailed docs for many of the interfaces in the Fuse.Reactive namespace.
    • The Fuse.Reactive.IWriteable interface has changed (breaking!). The method signature is now bool TrySetExclusive(object) instead of void SetExclusive(object). Unlikely to affect your code.


  • Fixed a regression causing iOS apps not to be accepted to the Store apparently due to use of push-notifications even though they are not used in the project.* IObservable and IObservableArray no longer push their initial value on Subscribe.
Tool updates
  • Fixed an issue where some users had to log in again every time Fuse started
  • When starting Fuse 1.4 for the time, you will be logged out even if you were logged in with a previous version
  • New and improved dashboard
  • Fixed an issue on macOS where we kept polling for the installation status of Sublime and the Sublime plugin even after closing the Setup Guide window. This would cause a Fuse icon to appear and disappear periodically in the Dock, stealing focus from other applications
  • Fixed an issue that made Fuse crash on macOS when clicking a menu item, when running various software with access to control the computer (like Moom, EVE and possibly others).
  • Fixed console output so errors are written to stderr and other output to stdout
  • Fixed so the logger names in fuse.log correspond more closely to the source of the message
  • Added new command fuse unoconfig which prints the current Uno configuration. fuse preview now also accepts a flag --print-unoconfig which will print the current Uno configuration before starting preview
  • Removed Ant from fuse install android, as it is no longer used
  • Added Restart to the Viewport menu
  • Fixed an issue where fuse install android would fail on macOS with case sensitive file systems
C++ backend
  • The following unused entities were removed from Uno/Memory.h:
    • uGarbageCollect()
  • The following unused entities were removed from Uno/ObjectModel.h:
    • uArray::Copy()
  • Added NewGuid() & ToByteArray() to Guid.
  • Added support for customizing settings.gradle by using [Require Gradle.Settings="include ':something'"].
Uno compiler
  • We now check that finally clauses don't contain illegal control flow. break, continue and return are not allowed in finally clauses.

Download this version

Fuse 1.3.2

This is a hotfix release that fixes the issues listed below.

These issues are also fixed in 1.4 which will be released shortly, so feel free to skip this release if you'd rather wait for that one.

  • Fixed a regression where args.sender was no longer the ux:Name of the parent of the trigger.
  • Fixed a bug where an internal argument could unexpectedly become null.

Download this version

Fuse 1.3.1

This is a hotfix release that fixes the issues listed below. If you're not affected by any of these, feel free wait for 1.4 instead, it's right around the corner! :)

  • Fixed an issue where PageControl.ActiveIndex would not update if navigation done with JavaScript seekToPath or Router interfaces.
  • Increased limit of max open files on macOS from 1024 to 9999, to avoid "Too many open files" error.
  • Fixed an issue on macOS High Sierra where fuse install sublime-plugin would not work.

Download this version

Fuse 1.3.0


  • You can now create UX classes inside Fuse Studio.
  • Faster preview refreshing of large apps on-device
  • A ton of performance optimizations and bug fixes in Fuse libs. (Including one nasty one which caused issues with Android 8).
  • Android release builds should be much smaller now.
  • New features to allow better navigation control from UX markup.



Note: On macOS, the ID of the Fuse application has changed, and you will get a popup from macOS saying: «Fuse Studio wants to use your confidential information stored in "Fuse Pro - Token" in your keychain.» Please click «Always Allow» in this dialog, or Fuse will be unable to keep you logged in between sessions.

  • Refreshing previews of large apps on mobile devices is now much faster.
  • You can now Restart a preview from the Viewport menu in order to reset all the app state.
Create class from selection (Pro)
  • You can now create an UX class from an instance element. Effectively this means you can create new components without switching out of Fuse Studio.
Inspector (Pro)
  • Removed "current color" from the Windows color picker, since the new color is updated in real time rather than when the user clicks "ok"
  • Removed MaxLength from the Text inspector. This attribute is deprecated, and the inspector for it has a bug
  • Compact Mode is now always called "Compact Mode". Previously, it was referred to as "Compact View" in some places
  • Gradient stops can now be added from the inspector
  • Added PageControl and Page to the primitives bar
  • Add ClientPanel and Button to the primitives bar
  • Installing Android SDKs (fuse install android) can now be done from the Tools menu
Misc bug fixes
  • Fix crash when attempting to remove root element from hierarchy
  • Fix problem in log view with multiple log messages printed on one line
  • Fix preview not appearing when Fuse is used by multiple user accounts on Mac
  • Fix indentation when moving or adding elements spanning several lines
  • Removing elements using the main menu no longer causes Fuse to crash
  • Fixed an issue where fuse install android would fail on macOS with case sensitive file systems
  • Fixed a (minor) memory leak


Native UI:
  • Fixed bug on iOS that could cause native views from thirdparty libraries to get an incorrect position. (Fixes issues with Firebase AdMob)
  • Added several features to allow navigation/routing from within UX, whereas previously JavaScript code was required.
  • Added ModifyRoute, GotoRoute and PushRoute actions to replace RouterModify. These all have a Path property.
  • Added gotoRoute, pushRoute, and modifyRoute expression events which allow for simple navigation in event handlers.
  • Added Navigator.Pages to bind the local history to an observable/model
  • Added PageControl.Pages to bind the list of available pages to an observable/model
  • Fixed the semantics of PageControl.ActiveIndex to work with dynamic pages. The output, getter, will only be updated when the navigation is intentionally changed to a new page. Previously it would always reflect the current page, which causes problem with dynamic pages. The variation between the desired target and actual target only lasts while the desired target is not yet rooted.
  • Changed how Router maintains history. This resolves several minor issues, including local histories (though this isn't fully exposed yet). It's intended to be backwards compatible for all known use-cases.
  • Changed IRouterOutlet and related types to be internal. This was not meant to be public as it's a private detail of the navigation system and could not be implemented correctly by users.
  • Removed the Navigator IsReusable property. These were deprecated over a year ago. Use Resuse="Any" instead.
  • Removed PageControl.TransitionEasing and Pagecontrol.TransitionDuration. These were deprecated over a year ago. Use a NavigationMotion object instead with GotoEasing and GotoDuration properties.
  • Removed PageIndicator.DotTemplate and PageIndicator.DotFactor. These were deprecated over a year ago. Use a ux:Tempate="Dot" child instead.
  • Removed Navigation.PageData. It was always meant to be internal and has no public use.
  • Allowed GoBack and WhileCanGoBack on the router to properly interact with bound observable/model PageHistory
JavaScript: Optional explicit require() of UX symbols
  • Symbols declared with ux:Name, ux:Dependency or dep are now also available to require() for <JavaScript> modules using the ux: prefix. This allows us to write code that plays nicer with transpilers and linters. Using require for names declared in UX is optional, but may make the code more readable and maintainable, e.g. var router = require("ux:router") over just using router with no declaration.
  • Fixed a problem where horizontal or vertical lines would not draw in the .NET backend.
  • Fixed an issue with attract not updating when using a data binding as the source value
  • Fixed bug where the default font on Android could end up being null.
  • Fixed issue where Images with Mask could end up not displaying. This happened due to unnecessary invalidation of the implicit native GraphicsView in the app root. This invalidation was introduced when the Surface API was implemented for native. Invalidation is now opt-in on ViewHandle
  • Fixed issue where Circles could draw incorrect due to floating point precision
  • Fixed issue where Rectangles could render incorrectly on mobile devices with FP16 precision limitation.
  • Added ScriptPromise. This adds support for passing Promises between Uno and the scripting engine. Very useful when dealing with async stuff and JavaScript
  • Added ScriptReadonlyProperty. This feature lets you expose readonly data in JavaScript. Useful for exposing constants for example

Fixed issue where custom URI schemes were matched too greedily in URLs, making for erroneously intercepted URL requests.

Delay Push Notification Registration on iOS

On iOS you can now put the following in your unoproj file:

    "iOS": {
        "PushNotifications": {
            "RegisterOnLaunch": false

which will stop push notifications registering (and potentially asking for permissions) on launch. Your must then call register() from JS when you wish to begin using push notifications. On android this option & register are silently ignored.

  • Fixed issue where an <Image /> could fail to display inside a <NativeViewHost /> on iOS
  • Fixed an issue where a JPEG image from a misconfigured server using image/jpg would fail to load.
  • Fixed a bug where replacing the whole list of items with an empty list would not immediately remove the items from the UI.
  • Added ScrollViewPage which simplifies the creation of infinite scrolling lists
  • Added missing hit testing from Ellipse. If you relied on there not being any hit testing on an ellipse add HitTestMode="None"
  • Fixed an issue where certain triggers would not skip their animation/actions as part of the Bypass phase. This will not likely affect many projects, but may resolve some spurious issues where animations did not bypass under certain conditions.
  • Fixed an issue where WhileVisibleInScrollView did not respect the Bypass phase for element layout.
    • If you required this behaviour add Bypass="None" to the trigger -- in exceptional cases you can add Bypass="ExceptLayout" to get the precise previous behaviour, but it should not be required, and is only temporarily available for backwards compatibility.
  • Several triggers were modified to properly look up the tree for a target node, whereas previously they may have only checked the immediate parent. The affected triggers are BringIntoView, Show,Hide,Collapse, Toggle, TransitionState, Callback, CancelInteractions, Stop, Play, Resume, Pause, TransitionLayout, BringToFront, SendToBack, EvaluateJS, RaiseUserEvent, ScrollTo. This should only change previous behavior if the action was previously configured incorrectly and did nothing or already found the wrong node. Many of the actions have a Target to target a specific node, or TargetNode to specify where the search begins.
  • Changed/fixed Trigger to provide the trigger itself as the target node to a TriggerAction, previously it'd provide the parent of the trigger. The old behaviour was due to an old tree structure. This should have been updated a long time ago. This allows actions to reference the trigger in which they are contained. If you've created a custom Uno TriggerAction and need the old behaviour modify your Perform(Node target) to use target.Parent. Triggers should in general scan upwards from the target node.
  • Added minimal support to WhileVisibleInScrollView for changes in Element layout updating the status
  • Added support for the Surface API in native UI for iOS. Meaning that Curve, VectorLayer and charting will work inside a NativeViewHost.
  • Fixed issue on Android causing text to align incorrectly if being scrolled and unfocused.
  • Added possibility to use RowAlignment to align the elements in the major direction of the WrapPanel as well as in the minor.
  • Optimized UpdateManager dispatcher to deal better with high numbers of dispatches per frame (as when populating long lists).
  • Optimized how ZOrder was computed which improves layout and tree initialization speed. Inlcudes a minor change on the ITreeRenderer interface, unlikely to affect your code.
  • Optimized how bounding boxes are calculated (improves layout and rendering performance).
  • Optimized how render bounds are compounded for larger lists.
  • Several low-level optimizations that speeds up scenarios with long lists (e.g. scrollviews). Here are the Uno-level details:
    • Optimized the implementation of the Visual.Children collection to be an implicitly linked list. This avoids all memory allocation and shifting in connection with inserting and removing nodes from a parent, and ensures a O(1) cost for all child list manipulations.
    • Introduced new public API: Node.NextSibling<T>() and Node.PreviousSibling<T>(), which can be together with Visual.FirstChild<T>() and Visual.LastChild<T>(). The recommended way of iterating over the children of a Visual is now for (var c = parent.FirstChild<Visual>(); c != null; c = c.NextSibling<Visual>()) where Visual can be replaced with the desired node type to visit.
  • Fuse.Scripting now knows about the JS Date type, allowing instances to be passed to/from Uno in the form of Uno.DateTime objects. This support extends to databinding, NativeModules, ScriptClasss, and the Context.Wrap/Unwrap API.
  • Binding an object that does not implement IArray to a property that expects IArray will now automatically convert the value to an array of length 1.
UpdateManager changes (Uno-level)
  • Breaking change: Several entrypoints on UpdateManager now take a LayoutPriority enum instead of int as the priority argument. Very unlikely to affect user code code.
  • Fixed an issue where writes to FuseJS/Observables would not dispatch in the right order on the UI thread if interleaved with ScriptClass callbacks (slightly breaking behavior).
Fuse.Reactive framework changes (Uno-level)
  • These are breaking changes, but very unlikely to affect your app:
    • The DataBinding, EventBinding and ExpressionBinding class constructors no longer take a NameTable argument.
    • The Name and This expression classes has been removed. The UX compiler will now compile these as Constant expressions that contain the actual objects instead.
    • The IContext interface no longer contains the NameTable property.


C++ backend
  • Don't lazy initialize types without a user-defined static constructor. This removes a bunch of Foo_typeof()->Init() calls from generated code, for instance when accessing a static field, to reduce run-time overhead.
Deprecated importers
  • import BundleFile(FILENAME) and remaining parts of the importer system in Uno.Compiler.ImportServices has been deprecated. We can now pass the filename directly to the operator instead: import(FILENAME). The import operator returns a BundleFile object. The classes texture2D and textureCube contains Load() methods accepting BundleFile which can be used to import texture files, replacing the deprecated texture importers.

| Old syntax | New syntax | |--------------------------------|--------------------------------------| | import BundleFile(FILENAME) | import(FILENAME) | | import Texture2D(FILENAME) | texture2D.Load(import(FILENAME)) | | import TextureCube(FILENAME) | textureCube.Load(import(FILENAME)) |

Removed UXL variable 'Mono'
  • The UXL variable 'Mono' was removed, since the need of it was removed.
Improvements to Android builds
  • Strip SO files in release builds. This can massively reduce the size of the shipping app.
  • Use gradle to generate required .iml files. This should make us more flexible both to changes from Fuse & to changes from Google in Android Studio. There is now only 1 .iml generated and that is in the app sub-directory of the project and only for builds with the -d flag.
Resource Crunching
.NET backend
  • Validation of method signatures and data types when linking external assemblies has been improved. This revealed a few minor problems in UnoCore that has been fixed:
    • Uno.Net.EndPoint: Constructor is now internal because a compatible constructor doesn't exist in .NET.
    • Uno.Threading.Monitor.TryEnter(): Return type is now bool to match .NET.
    • Uno.Text.StringBuilder: This class now maps to System.Text.StringBuilder on .NET.
    • Uno.Tuple<...>: The AppendItems(StringBuilder sb) methods are no longer public because compatible methods don't exist in .NET.
  • Introduced Uno.Compiler.ExportTargetInterop.DotNetOverrideAttribute. This attribute is used to override implementations of static methods in types that are mapped to .NET, so that the Uno implementation is used instead of the existing .NET implementation. We use this on string.Format() because Uno only implements a subset of the functionality.
Uno.DateTime changes (breaking!)
  • Uno.DateTime was changed from being a class to a struct, to make it .NET-compatible
  • The UtcNow property has changed types from being Uno.Time.ZonedDateTime to being Uno.DateTime, to make it .NET compatible
  • The Now property has been made internal until better .NET-compatible support can be provided
Uno compiler
  • The compiler has become stricter about accessing entities from other packages. Previously it was in some cases possible to access internal entities from a different package without getting a build error.
  • The compiler now accepts empty structs. It's no longer necessary to add a dummy field to work around build errors when forward declaring .NET structs for instance.

Download this version

Fuse 1.2.1

This is a bugfix release, with the following fixes:

Android Release builds
  • Fixed an issue where release-builds for Android could result in an error about an undefined reference to std::exception::exception().
  • Fixed an issue where the ElementBatcher ended up throwing an Exception complaining about the element not having a caching rect.

Download this version

Fuse 1.2.0


  • A lot of engine performance improvements, resulting in faster, slicker apps!
  • Significant stability & performance improvements in the tooling as well.
  • Each has been extended with things like Reuse, Identity and IdentityKey - enabling new use cases and better performance (because unnecessary object allocations is still bad, even though we live in the future.)
  • UX expressions became even more powerful with support for arbitrary array lookups and variable arguments.

Fuse Studio Updates

  • Studio should be significantly faster and more responsive (and we'll keep improving it in future releases as well!)
  • Removing elements using the main menu no longer causes Fuse to crash
  • Gradient stops can now be added from the inspector
  • Fixed a (minor) memory leak
  • Added PageControl and Page to the primitives bar

General tooling & framework updates

Default packages included in the Windows installer
  • All the packages needed for a bare bones Fuse app are now included in the installer. This avoids the need to wait several minutes for the package manager when you first build a project after installing a new Fuse version
Using the tool while offline
  • Fixed a bug that meant that Fuse was not usable while not connected to the Internet.
Preview key events
  • Fixed a bug where AltGr keyboard presses inside a preview viewport would be sent to the main window which meant that it wasn't possible to type e.g. the '@' character on Nordic keyboards.
Code completion
  • Fixed UX completion for tags directly inside the App tag. Previously, you would only get completion when inside a second level tag.
  • Fixed an issue where the combination of -DUSE_HARFBUZZ, -DCOCOAPODS and certain Pods (in particular Firebase.Database has been identified) caused an app to link to symbols that the AppStore disallows.
  • Fixed an issue where removing an element would not actually remove the element
  • Fixed issue where an <Image /> could fail to display inside a <NativeViewHost /> on iOS
  • Added findRouter function making it easier to use a router in a page deep inside the UI
  • Fixed and issue where relative paths and nested Router gave an error about unknown paths
UX Expression improvements
  • Added parameter(page) function which returns the routing parameter of the page parsed as an JSON string.
  • UX expressions now support arbitrary array lookups, e.g. {someArray[index+3]}. The same syntax can also be used with string keys, e.g {someObject[someKey]}. The lookup is fully reactive - both the collection and the key/index can change.
UX Expressions (Uno-level)
  • Introduced support for variable arguments to UX functions - inherit from the Fuse.Reactive.VarArgFunction class.
  • The classes Vector2, Vector3 and Vector4 in Fuse.Reactive are now removed and replaced with the general purpose, variable-argument version Vector instead. This ensures vectors of any length are treated the same way. This is backwards incompatible in the unlikely case of having used these classes explicitly from Uno code.
  • Added support for name-value pair syntax: name: value. Can be used for JSON-like object notation and named arguments in custom functions.
  • Added Identity and IdentityKey to Each. This allows created visuals to be reused when replaced with replaceAt or replaceAll in an Observable.
  • Triggers may now use templates which will be instantiated and added to the parent when active (like a node child).
  • Added templates to NodeGroup, which can now be used in Each.TemplateSource and Instance.TemplateSource
  • Each, using TemplateSource, will no longer respond to template changes after rooting. This was done to simplify the code, and to support alternate sources, and is a minor perf improvement. It's not likely to affect any code since it didn't work correctly, and there's no way in UX to modify templates after rooting.
  • A memory leak was fixed by changing Instantiator.TemplateSource to a WeakReference. Only if you assigned this property a temporary value in Uno would this change impact your code.
  • Clarified/fixed some issues with how Each/Instances handled default templates. Previously if no matching template was found all the specified templates, or a subset, might have erronously been used. Now, as was always intended, if you use MatchKey and wish to have a default template you must specifiy ux:DefaultTemplate="true" on the default template. You cannot have multiple fallback templates, just as you can have only one template of a particular name.
  • If a ux:DefaultTemplate="true" is specified it will be the template that is used; the complete list of templates will not be used.
  • Fixed issue where using Fuse.Share would crash on iPad. Users must provide a position for spawn origin for the share popover. Check the Fuse.Share docs for more details.
  • Made iOS implementation internal, this was never meant to be public in the first place
  • Optimized hit testing calculations. Improves scrolling in large scroll views with deep trees inside, among other things.
  • Optimized redundant OpenGL rendertarget operations. Gives speedups on some platforms.
  • Optimized invalidation strategy for transforms, to avoid subtree traversion. This improves performance generally when animating large subtrees (e.g. scrollviews).
  • Backwards incompatible optimization change: The protected virtual void Visual.OnInvalidateWorldTransform() method was removed. The contract of this method was very expensive to implement as it had to be called on all nodes, just in case it was overridden somewhere. If you have custom Uno code relying on this method (unlikely), then please rewrite to explicitly subscribe to the Visual.WorldTransformInvalidated event instead, like so: Override OnRooted and do WorldTransformInvalidated += OnInvalidateWorldTransform;, Override OnUnrooted and to WorldTransformInvalidated -= OnInvalidateWorldTransform;, then rewrite protected override void OnInvalidateWorldTransform() to void OnInvalidateWorldTransform(object sender, EventArgs args)
  • To improve rendering speed, Fuse no longer checks for OpenGL errors in release builds in some performance-critical code paths
  • Improved perceived ScrollView performance by preventing caching while pointers are pressed on them, avoiding inconsistent framerates.
  • Fixed a bug which prevented elements like Image to use fast-track rendering in trivial cases with opacity (avoids render to texture).
  • Optimized how bounding boxes are calculated (improves layout and rendering performance).
  • Fixed issue where during multitouch all input would stop if one finger was lifted.
  • Added the option to opt-out of automatic handling of touch events when implementing a native view.
  • Added the attract feature, which was previously only in premiumlibs. This provides a much simpler syntax for animation than the Attractor behavior.
  • The experimental IGesture interface has changed.
    • The Significance, Priority and PriotityAdjustment have been merged into the single GetPriority function.
    • OnCapture is changed to OnCaptureChanged and provides the previous capture state
  • Clicked, DoubleClicked, Tapped, DoubleTapped, and LongPressed have been corrected to only detect the primary "first" pointer press. If you'd like to accept any pointer index add PointerIndex="Any" to the gesture.
  • SwipeGesture, ScrollView, LinearRangeBehaviour (Slider), CircularRangeBehaviour, Clicked, Tapped, DoubleClicked, DoubleTapped, LongPressed, WhilePressed all use the gesture system now. They have a GesturePriority property which can be used to adjust relative priorities -- though mostly the defaults should be fine.
  • The SwipeGesture.GesturePriority default is changed from High to Low. This better fits with how the priorities should work together in a typical app and in general shouldn't affect any usual layouts. You can alter the priority with GesturePriority="High"
Each Reuse
  • Added Reuse to Each allowing the reuse of nodes
  • Added OnChildMoved to Visual. Anything implementing OnChildAdded or OnChildRemoved will likely need to implement OnChildMoved as well. This happens when a child's position in Children list changes.
  • Added OnChildMovedWhileRooted to IParentObserver
  • Added How property to WhileVisibleInScrollView trigger that accepts values Partial (default) and Full. When set to Full, the trigger is only active when the whole element bounds are inside view.
Broken Uno tools removed
  • uno perf-test and uno perf-cmp were unused and broken, and have been removed.
  • The unused class Uno.FakeTime has been marked as obsolete.
  • The ExportCondition attribute in Uno.Compiler.ExportTargetInterop has been marked as obsolete.
  • The legacy Alert and Confirm methods in Uno.Diagnostics.Debug has been marked as obsolete.
  • The redundant SupportsMipmap fields in Uno.Graphics has been marked as obsolete.
  • The constant float.ZeroTolerance has been marked as obsolete.

Download this version

Fuse 1.1.1

Hotfix 1.1.1
  • Fixed an issue where Activated and WhileActivated within an EdgeNavigator did not correctly identify an active state
  • Changed EdgeNavigation to return a page in Active when no side-panels are active
  • Fixed a crash in the iOS implementation for Fuse.Share that could happen on iPad.
  • Fixed a bug where disposing a JavaScript tag that has called the findData-method could lead to a crash.

Download this version

Fuse 1.1.0


  • Lots of new UX expression functions - including the Each-index we've all wanted for so long!
  • UX compiler has been optimized to reduce compile times and improve editing speed in Fuse Preview. (Real-time preview is now even more real-time.)
  • Control build flags from within Fuse (not just on the command line)
  • HLS video streams should now also work on iOS.
  • Finally got rid of the Freetype- / SIGILL-related crashes on older Mac models. (Thanks Olle! Enjoy the time off with your family!)
  • Added MapMarker.Tapped to make it easier to poke your place of residence.

In addition to a lot of other fixes & features.


Build flags dialog
  • Added a new dialog for adding build flags (like -DDEBUG_V8) from within Fuse. It can be found in the Preview menu.
File watching
  • Fixed a bug where Fuse sometimes failed to notice when a file in a project had been created.
Update notificaitons
  • Fixed a bug where the change log would not show up in update notifications
Inspector (Fuse Studio)
  • Replaced the TextTruncation setting for text controls with an option for configuring MaxLength instead.
  • Fixed a bug where the value of certain editors would take on the value from a previously selected element when selected on macOS.


  • KEEP_ASPECT is no longer ignored on Android when using ImageTools.resize
  • Fixed bug in Android implementation that could result in exceptions due to prematurely recycled bitmaps
  • Added supported for encoding/decoding images to/from base64 on DotNet platforms, including Windows and Mac OS X.
  • iOS: Fixed crash when using Fuse.Camera alongside <iOS.StatusBarConfig IsVisible="false" />
  • Fixed bug on iOS where URIs were incorrectly encoded, leading to some input with reserved URI-characters misbehaving.
  • Added .list() to fetch a list of all bundled files
  • Added .readBuffer() to read a bundle as an ArrayBuffer
  • Added .extract() to write a bundled file into a destination path
  • A Url-based Image that has failed to load will now retry when the Url is used again in a new Image
  • Added reload and retry JavaScript functions on Image to allow reloading failed images.
  • Fixed infinite recursion bug that could happen if a MemoryPolicy is set on a MultiDensityImageSource
  • Fixed issue where the animation could become out of sync if the properties on ScrollingAnimation were updated.
macOS SIGILL problems
  • Updated the bundled Freetype library on macOS to now (again) include both 32-bit and 64-bit symbols, which fixes an issue where .NET and preview builds would crash with a SIGILL at startup when running on older Mac models.
  • Updated the bundled libjpeg, libpng, Freetype, and SDL2 libaries for macOS to not use AVX instructions, since they are incompatible with the CPUs in some older Mac models. This fixes an issue with SIGILLs in native builds.
  • Added feature toggle for implicit GraphicsView. If you are making an app using only Native UI disabling the implicit GraphicsView can increase performance. Disable the GraphicsView by defining DISABLE_IMPLICIT_GRAPHICSVIEW when building. For example uno build -t=ios -DDISABLE_IMPLICIT_GRAPHICSVIEW
  • Fuse.Input.Gesture now only has an internal constructor. This means that external code can't instantiate it. However, this was never possible to do in a meaningful way, so this shouldn't really affect any applications.
Native TextInput
  • Fixed issue where focusing a <TextInput /> or <TextView /> by tapping it would not update the caret position accordingly.
Route Navigation Triggers
  • Activated, Deactivated, WhileActive, WhileInactve have all been fixed when used inside nested navigation. Previously they would only consider the local navigation, not the entire tree. If the old behavior is still desired you can set the Path="Local" option on the navigation.
  • Activated, Deactivated have been fixed to only trigger when the navigation has stabilized. If you'd instead like to trigger the moment the active page changes, which is closest to the previous undefined behavior, set When="Immediate"
  • The NavigationPageProxy use pattern has changed. Rooted is removed, Unrooted is now Dispose, and the constructor takes the parent argument. This encourages a safer use (avoiding leaks).
  • Fixed a crash in the rooting of certain tree structures using any of the Navigation triggers such as WhileActive
  • Support MapMarker icon anchor X/Y/File properties when setting MapMarkers via JS
  • Added <MapMarker Tapped="{myHandler}"/> to retain the data context for each tapped marker.
  • Added <MapView AllowScroll="false"/> to disable the user panning and scrolling around.
  • Fixed a bug causing crashes on iPhone 5s devices when using ShowMyLocation="true"
  • Added <WebView ScrollEnabled="false"/> to disable the user panning and scrolling around.
  • Added QuickUnload memory policy to keep data in memory for as short as possible.
  • Fixed a bug where HLS streams would become zero-sized on iOS.
Expression functions
  • added index and offsetIndex as funtions to get the position of an element inside an Each
  • added functions mod, even, odd, and alternate to complement the index functions. These allow visually grouping elements on the screen based on their index.
  • added trigonometric math functions sin, cos, tan, asin, acos, atan, atan2, radiansToDegrees, degreesToRadians
  • added math functions abs, sqrt, ceil, floor, exp, exp2, fract,log, log2, sign, pow, round, trunc, clamp
  • added lerp function for linear interpolation between values
  • Fixes a bug where the app would crash if a databinding resolved to an incompatible type (e.g. binding a number property to a boolean value). (Marshal.TryConvertTo would throw exception instead of fail gracefully).
Fuse.Box / Fuse.Ray
  • Uno.Geometry.Box and Uno.Geometry.Ray has been replaced with Fuse.Box and Fuse.Ray.


UX Compiler/Fuse Preview Optimizations
  • Many optimizations to the UX compiler to reduce compile times and improve editing speed in Fuse Preview.
  • Android's allowBackup option is now configurable via the optional Android.AllowBackup value in the unoproj file
  • Registry.FindTest() has been removed.
  • TestSetup.Runner has been marked as readonly.
  • Assert.Ignore() has been added to allow ignoring tests at run-time.
  • A bug in Assert.AreNotEqual(float, float) and Assert.AreNotEqual(double, double) has been fixed, to make them format the result strings similar to their Assert.AreEqual counter-parts.
  • TestAttribute and IgnoreAttribute have gotten the apropriate AttributeUsages to match their behaviour. This means that using them outside of methods will now give compile-errors instead of doing nothing.
  • A bunch of internal details that were never intended to be public has been marked as internal:
    • AbstractRunner
    • DebugLogMessageDispatcher
    • AssertionFailedException
    • HttpMessageDispatcher
    • NamedTestMethod
    • Registry.Add()
    • Registry.Count
    • NamedTestMethod Registry[int index]
  • Fixed a bug where a JSON object with the same key repeated would cause a crash.

Download this version

Fuse 1.0.3

Download this version

Fuse 1.0.2

Hotfix 1.0.2

Fixed fuse install android issue, where cmake failed to install.

Download this version

Fuse 1.0.1


  • Fixed Android build error in NDK R15.
  • Fixed an issue when loading images bigger than the maximum texture-size. Instead of failing, the image gets down-scaled so it fits.
  • Fixed issue where apps would not redraw when returning to Foreground.
  • Fixed an issue that would result in a broken layout if a Sizing="Fill" was used where there wasn't enough space for one column.
Fuselibs Updates
  • Fixed an issue that would result in a broken layout if a Sizing="Fill" was used where there wasn't enough space for one column.
Bug in Container
  • Fixed bug in Container which caused crash when the container had no subtree nodes. This caused the Fuse.MaterialDesign community package to stop working.
  • Fixed a bug where we would trigger errors on Android if a live-stream was seeked or paused.
  • Fixed an issue when loading images bigger than the maximum texture-size. Instead of failing, the image gets down-scaled so it fits.
  • Fixed issue where apps would not redraw when returning to Foreground
  • Fixed possible nullref in Scroller that could happen in certain cases while scrolling a ScrollView
  • Fixed nullref in Scroll that could happen if there are any pending LostCapture callbacks after the Scroller is Unrooted
  • Fixed an issue where the rendering of one element could bleed into the rendering of another element under some very specific circumstances.
Fuse Studio Updates
Command-line arguments

The preview command now (again) forwards defines (-D flags like -DDEBUG_V8) and verbosity flags (-v) given on the command-line to local preview.

MacOS window

The tool's window is now zoomed when the titlebar is double clicked.

Attributes section

The type of a property is now shown as the placeholder text of its editor in the attributes section of the inspector.

Project menu
  • Fixed a bug where Fuse Studio would crash when opening files from the project menu on some systems.
Uno Updates
Fixed Android build error in NDK R15
  • Fixed use of undeclared identifier 'pthread_mutex_lock_timeout_np' build error when using NDK R15, that was reported here.

Download this version

Fuse 1.0.0

  • Fuse Studio released!
  • Charting (Premium component)
  • Xcode & Android Studio integration (Premium component)
  • UX kit (Premium component)
  • CameraView (Premium component)
  • Dark Theme for the tool
  • New warnings / problems tab to help you out with missing databindings (and much more!)
  • And finally an option for clearing the log window

There's a lot going on in this release so make sure to read on...

Fuse Studio and Premium components

This release introduces several major tools & features. Most notable here is the first version of the Fuse Studio visual tooling.

Fuse Studio, together with a set of feature packages that we call Premium Components, are available as part of our paid Professional & Custom subscription plans. You can also get a free 30-day trial license here. Once you have a license you just click "Log In" in the Fuse dashboard and enter your account details.

Fuse Studio key features
  • A hierarchical overview of your app that makes layout and UX structuring even more intuitive.
  • Basic UX markup editing by dragging & dropping default primitives and custom components.
  • Inspector for easy tweaking & discovery of element attributes - from colors & layout to data bindings.
  • Multiple preview viewports. View different resolutions, pages and states side-by-side to see how your changes affect the whole app.

See the docs here

As you can probably imagine, this release is a Big Deal for us. That said, the most important thing is not what Fuse Studio does today (although that's pretty cool) but how it will keep evolving with large & small features that'll make life easier for all of us when developing apps.

Xcode & Android Studio integration (Premium component)

Create custom components in Fuse and export them as native libraries for use in your existing native projects. Read more here about how you can sprinkle Fuse awesomeness on your legacy code.

Charting (Premium component)

A powerful set of tools to easily create great-looking graphs and charts in your apps. Docs

Alive UX Kit (Premium component)

A collection of great-looking UI components for a wide range of use cases. Customise & evolve to your exact needs or use as-is. Docs

CameraView (Premium component)

A native view providing a customisable camera preview and photo functionality. (Yes, this means stickers-on-top-of-the-camera-stream!) Docs

Other Updates
Dark theme
  • Added a new dark theme for the Fuse application, which is now the default. It can be switched to the light theme in the "Window" menu.
Log view
  • Output in the log view is now grouped by the originating device
  • Added a button to clear the log
Problems tab
  • Added a new tab in the bottom panel called 'Problems', which shows temporary runtime errors or messages reported by apps.
  • Shows Javascript syntax errors or exceptions, with a button to goto location
  • Shows warnings when databinding sources aren't found
  • Fixed an issue resulting in the app being reified multiple times on rebuild
  • Made the selection indicator visible for a second every time the selection changes even when the selection switch is off. This makes it easier to see what's selected when using the "Select element at caret" option.
  • Fixed a problem that resulted in the simulator sometimes being reified with old attribute values
Various tool fixes
  • Fixed an issue where the log view tab would always overlap the app, and sometimes be misplaced in the UI
  • Fixed spacing in the top bar. In particular, the compact view toggle was sometimes not displayed in compact view
  • Fixed an issue where builds would sometimes fail due to connection errors to the package manager backend
  • Fixed an issue where it was possible to resize panes such as the log view so large that it couldn't be resized back
  • Improved startup time on macOS
  • Fixed retrying after failed attempt to read locked file
Animation engine fixes
  • Fixed a bug where elements with many children and some of them were rotated, the rotated elements would appear in the wrong location

Download this version

Fuse 0.37.0

  • Fuse libraries have reached version 1.0! (Fanfare!)
  • Brand new unified user interface!
    • Smoother UX editing experience thanks to less reifying of the preview
    • Locate in editor
    • Rebuild without closing preview
    • Improved error reporting for device preview
  • New vector API for drawing curves, shapes, and simple vector images.
  • ux:Test for unit testing
  • Lots of bug fixes & improvements.
New tooling

Note: Right now you must have a local preview running on your computer in order to also preview on device(s).

Unified UI

Preview, monitor, dashboard, setup and most of the tray has been merged into a new unified Fuse UI. This leads up to more integrated tooling in the future and also helps us get rid of a lot of quirks and issues in the old dashboard. Note: you can still work with the small preview window that you're used to, just click the "Compact View" switch in the top right corner.

Less reifying of the preview when editing UX

Previously, any changes to the UX markup would cause the preview app to reify (reset back to its starting state). We are now able to detect simple changes to the UX and update the preview without reifying. This is a new feature, so if you encounter any problems, or for any other reason want a full reify, use Preview -> Refresh, or Cmd+R / Ctrl+R.

Locate in editor

When you have selection enabled (previously known as "design mode"), you can press Cmdl+Alt+L / Ctrl+Alt+L . If you have your project open in Sublime or Atom your editor will navigate to the ux code for the currently selected element and your editor will get focus. Pressing the same hotkey again switches focus back to Fuse.

Full rebuild without closing preview

Using Preview -> Rebuild or Shift+Cmd+R / Shift+Ctrl+R you can now rebuild your preview app without closing the preview window. This is especially handy if you are writing Uno and foreign code.

Improved error reporting for device preview

Previously, certain errors would never reach the user. Specifically, when trying to preview on device Fuse needs the code to also compile for local preview. If it failed to do so the errors were never reported and you were left staring blankly at the screen, waiting for something to happen. This is now fixed. (If you've ever been told to do fuse host-preview --compile-only, it was because of this issue.)

iOS Backend

Fixed a problem that resulted in "FATAL ERROR: value cannot be null" when building for iOS without having set a development team manually.

Fuse libraries 1.0
Vector drawing

A new vector drawing system has been added to Fuse. This allows drawing of curves, shapes, and simple vector images. - Added Curve which allows drawing of lines and polygons. CurvePoint can be used to bind to JavaScript observables and servers as the basis for drawing line graphs - Reintroduced Path, Ellipse, Star and RegularPolygon. These are all backed by the new vector system. - Added several options to Ellipse to allow drawing wedges, like with Circle - Added Arc for drawing the outside edge of an Ellipse - Added elliptic arc support to Path to support more SVG path data - Removed FitMode.StrokeMaximum and FitMode.ShrinkToStroke as they could not be reliably supported or behave in a reasonable fashion. To fit accounting for stroke use a wrapping panel with padding instead. - Removed Path.ScaleMode as stroke scaling is not supported as it was before - Remove the Fuse.Drawing.Polygons and Fuse.Drawing.Paths packages. Their functionality has been replaced by the new vector system - Fuse.Controls.FillRule has moved to `Fuse.Drawing.FillRule

  • Fixed a bug causing crashes on iPhone 5s devices when using ShowMyLocation="true"
  • Fixed a bug where the MemoryPolicy given would not be correctly used.
  • Defer="Deferred" on Instance/Each allows the deferred creation of nodes without the need for a Deferred node
  • Deferred now has an implied priority based on the node depth. Items with equal Priority will now be ordered based on tree depth: deeper nodes come first.
  • Changes to the items will now be collected and new items added once per frame. This avoids certain processing bottlenecks. This should not cause any backwards incompatibilties, though the option Defer="Immediate" is available to get the previous behavior.
Page busy
  • A Page will now be busy for the first frame (or two) after it is prepared. This will block the Navigator from starting the transition during those frames, which should improve first frame jerkyness. The PrepareBusy property can be set to None to disable this behaviour.
Text edit controls
  • Fixed the behaviour of placeholder text in the text renderer used when targeting desktop. The placeholder text is now always visible when there is no text in the text control, even when it has focus.
  • The GeoLocation module no longer throws an exception if there are no listeners to the "error" event when there is an error.
  • Fixed an omission that meant that the old way of listening to GeoLocation events (using GeoLocation.onChanged = ... instead of the recommended EventEmitter GeoLocation.on("changed", ...)) did not work.
  • The Stroke will no longer emit property changed events for its Brush unless it is pinned. This is not anticipated to be an issue for any projects.
  • A new static Uno class has been introduced, called Fuse.Version. It contains fields for the major, minor and patch-version, as well as a string with the full version number.
  • Add implementation for android.view.TextureView to better support multiple <GraphicsView />'s and <NativeViewHost />'s on Android.
  • In order to fix a memory leak in Container the pre-rooting structure was changed. Children of the container will not be children of the Subtree until rooted. It is not believed this will have any noticable effect; other features, like Trigger, also work this way.
  • Extended the ability of gestures at multiple levels in the UI tree to cooperate, or take priority
  • SwipeGesture now has priority over ScrollView, even if in an ancestor node
  • Edge swipes have priority over directional swipes, regardless of the node they are in
  • Removed SwipeType.Continuous as it did not work correctly and wouldn't fulfill the known use-case even if it did. Consider using Auto instead.
  • Deprecated public access to the Scroller class. This is an internal class and should not be used. All functionality is accessible via ScrollView
  • Added SwipeGesture.GesturePriority and ScrollView.GesturePriority to adjust priorities
  • Fixed an issue where a higher level capture where preempt one lower in the UI tree
  • The then argument to BeginRemoveChild is now an Action<Node> to provide the node to the callback. Add an Node child argument to the callback function.
  • The interfaces IObservable, ISubscriber and IObserver are no longer public (affects any class that implements them). These were made accidentally public in Fuse 0.36. These need to be internal in order to allow behind-the scenes optimizations going forward.
  • Changed the algorithm for creating new file names for temporary images. Previously this used a date format that caused problems when several images were created in sub-second intervals, breaking custom map marker icons, for instance.
  • Fixed a memory leak that occured when resizing multiple images one after another.
Default Fonts
  • Added the following default-fonts, that can be used like so <Text Font="Bold" FontSize="30">This is some bold text</Text>:
    • Thin
    • Light
    • Regular
    • Medium
    • Bold
    • ThinItalic
    • LightItalic
    • Italic
    • MediumItalic
    • BoldItalic
  • Due to a bug in Mono we have temporarily removed support for PlaySound in preview on OSX.
Add ux:Test support in UX compiler
  • The UX compiler now supports ux:Test, which is similar to ux:Class but generates a bootstrapped test class which can be run with uno test. See docs for details.
Add 'uno sdkmanager'
  • This lets you use Android's new CLI sdkmanager. The old uno android approach is deprecated.
New UX Markup features
  • Introduced <ux:Resources> tag which can be used as the root tag in UX files that contain only ux:Class'es and ux:Global's. This avoids having to use a "dummy panel" to encapsulate such resources.
iOS Screen Rotation
  • Fixed a bug that broke layout when rotating the screen on iOS
  • Fix bug which could cause visual glitches the first time rotating from Portrait to Landscape
Other Bugfixes
  • Fixed a bug (regression in 0.36) where functions could not be used as data context in event callbacks.
  • Fixed a bug where strings like "20%" did not marshal correctly to Size when databound.

Download this version

Fuse 0.36.1

This is a bugfix release that fixes the following:

Android Signing

Our last release suffered from a regression where apps built for release without signing keys failed to install on android devices. We now sign them with a debug signing key in those cases.


  • iOS: Fixed incorrect view recycling for custom MapMarker icons.
  • iOS: Fixed ginormous custom MapMarker icons.
  • Minor improvements

Download this version

Fuse 0.36.0


  • All Android builds now use Gradle and CMake. (No more -DGRADLE required)
    • Note: Google only provides 64bit support for these tools on Windows. If you have a 32bit Win machine you will no longer be able to export Android apps.
  • The new Harfbuzz text renderer is now default in local preview (and has received a lot of bug fixes)
  • UX expressions now also work on animators.
  • Added support for sharing text and files with other applications through the Fuse.Share package
  • And a lot of other bug fixes and changes. Read the full list for details (it's worth it!)
Harfbuzz text renderer
  • The Harfbuzz text renderer is now the default text renderer in local preview and desktop builds. The new renderer supports complex text with emoji, bidirectionality, ligatures, etc. It is also faster than the old renderer. It's also possible to use this text renderer on mobile devices by building with -DUSE_HARFBUZZ (just like before).
  • Fixed an issue where text elements with many lines would be measured incorrectly due to rounding.
  • Fixed a bunch of bugs in the desktop text edit control when using the Harfbuzz text renderer. Some examples of bugs that were fixed are:
    • Not being able to move to the first line if the text control started with multiple newlines.
    • The cursor moving before the inserted character when adding text on the first line if that line is empty.
    • The cursor jumping to the wrong position when moving left and right in certain bidirectional strings.
    • The caret ending up in slightly off positions when moving up or down in multi-line text.
All Android builds now use Gradle & CMake

What this means for you is as follows:

  • You no longer have to use the -DGRADLE flag when building for Gradle support
  • You will be able to use a simple Uno attribute to install any of the mountain of libraries available for the android platform via Maven & JCenter
  • The projects we generate should be compatible with Android Studio. Build with -d to open the project in AS. (Note: We currently aren't providing support for this workflow as changes to Android Studio are out of our control.)
  • If you haven't used Gradle builds before then you will probably need to do fuse install android again. The very first Android build you do will also take a bit longer than before, but after that it should be all good.

So what's the deal then? Back in 2013 Google announce they would be changing their supported build system to Gradle and that Ant would be deprecated. Since then Gradle and android have grown to the point where Gradle is now 'the way' to build and manage your dependencies for Android projects. The road for native development has been much rockier especially if, like us, you interact with Android from an external tool.

However we are finally in the position where we are happy enough with stability and compatibility that we are going to remove the deprecated Ant build system and switch to Gradle for all builds. We have been offering Gradle builds from Fuse using a build flag for a long time and the input from users has been invaluable.

This does however have an effect on what themes are available for Native widgets. The reason for this is that more and more 3rd party android libraries (such as Facebook's login UI) are using UI elements (or other features) not available on older android versions. To keep to our high standard of device & version compatibility this required us to switch from using com.android.Activity to android.support.v7.app.AppCompatActivity. This provided compatibility versions of the APIs needed but means that the supported Android native themes must inherit from AppCompat.Theme

That means that the Holo will no longer work with Fuse apps although Theme.AppCompat, Theme.AppCompat.Light, etc will.

As always please reach out to us if you hit any issues.

  • Preview is now refreshed when moved between different density screens on macOS.
Android Manager
  • Several users have ran into 'Failed to find package cmake;3.6.3155560', this release contains a fix for that. However, please run fuse install android again if you've encountered it.
  • Fixed issue reported by a few users, where fuse install android might fail because of HTTPS issues.
Android Studio Details
  • We no longer generate the .iml files and instead let Android Studio do this.
  • Added Fuse.Share package enabling the sharing of text and files with other applications. Read more about the share module here.
Duotone effect
  • An effect that applies a duotone filter with customizable colors. Read more about Duotone here.
  • Added PointerCapture as an explicit way to capture the pointer and do compound controls (experimental). Learn more about the PointerCapture class.
UX Expressions
  • Fixed bugs which prevented use of UX bindings and expressions on animators, e.g. <Change foo.Value="{Resource bar} / 2"
  • UX expressions are now also supported in FileSource properties, e.g. <Image File="Assets/{img}.png" />. Remember to include the files in the :Bundle in your .unoproj.
  • Fixed inconsistencies with how Timeline implemented Resume, Pause, and Stop. They now work in the same fashion as other media playback, such as Video. If you happened to depend on the old behaviour you can use the new TimelineAction.
  • Added TimelineAction for extended control over a Timeline without mimicing media playback
  • Deprecated PlayTo, use TimelineAction instead
  • Deprecated Resume, use Play instead
  • Deprecated several items in IPlayback as they are redundant. It is strictly a simple playback interface now.
  • Fixed several layout issues with WrapPanel and WrapLayout
    • text should wrap correctly now
    • Padding is now applied
  • Added WrapPanel.RowAlignment to align contents to the top/bottom/center of a row
  • Fixed an incorrect change of ScrollingAnimation.Range if To or From were set. They would force an Explicit mode, but now only do that if the Range has not been set before. The behaviour of something like <ScrollingAnimation Range="SnapEnd" To="100"> thus changes (it was undefined before, and is still undefined behaviour, as SnapEnd doesn't accept To/From values)
  • Modified capturing on ScrollView and SwipeGesture to allow them to both exist on the same parent node and be usable at the same time.
  • Added CycleWaveform.Square
  • Added CycleWaveform.Offset
  • Json.Escape has been marked as obsolete, as it didn't correctly quote everything needed. Use Uno.Data.Json.JsonWriter.QuoteString instead. Note that JsonWriter.QuoteString also adds quotes around the result, so it's not a pure drop-in replacement.
  • Fixed a bug where changes to Page.Title were not propagated properly to Property-bindings.
  • Changed Brush to use premultiplied alpha rendering which resolves several unpleasant visual anomolies
  • Changed LinearGradient to interpolate using premultiplied alpha
  • Removed Brush.BlendMode as it wasn't working correctly, and cannot actually be supported correctly
  • Added LinearGradient.Interpolation and set the default to Linear. Previously this would, incorrectly, do a smoothed gradient. To get the previous behaviour use Interplation="Smooth", but note it is not supported on all renderers.
  • Fixed an issue where the animation Scale property was not applied at rooting time
  • PageResourceBinding has been marked as deprecated. Instead of <PageResourceBinding Target="Bar.Prop" Key="Foo" /> Use Prop="{Page Foo}" on Bar instead.
iOS Launch Options
  • Using foreign code you can now access the latest launch options in iOS apps as a ObjC.Object from the Uno.Platform.iOS.Application.LaunchOptions property.
.NET backend
  • Worked around an issue that resulted in errors like ERROR: Failed to compile .NET type 'XXX': The invoked member is not supported before the type is created. when using certain class attributes when compiling for .NET (e.g. local preview)
  • This package has been moved to the Uno repository. The following methods that were marked as obsolete in Fuse 0.33 have now been removed:
  • Socket.Send(byte[], int, int)
  • Socket.Receive(byte[], int, int)
  • JsonReader.AsStringOrDefault() has been marked as obsolete, and should be replaced with JsonReader.JsonDataType and JsonReader.AsString(), e.g code like foo.AsStringOrDefault() shoud become foo.JsonDataType == JsonDataType.String ? foo.AsString() : null.
  • The following JsonReader methods have been marked as obsolete, and should be replaced with calls to AsNumber() instead. The OrDefault variants should check JsonDataType first, similar to the previous point:
    • AsFloat()
    • AsFloatOrDefault()
    • AsDouble()
    • AsDoubleOrDefault()
    • AsInteger()
    • AsIntegerOrDefault()
  • JsonReader.AsBoolOrDefault() has been marked as obsolete, similar to the previous points, and need similar care.
  • IFrustum.GetProjectionTransform and IFrustum.TryGetProjectionTransformInverse has been changed signature to bool TryGet...(..., out float4x4) so attempts to divide by zero etc can be reported to the call-sites.

This is a series of advanced changes that should not affect UX level code.

  • The public interface of Input.Pointer has changed to allow for extended gesture support. There is a behaviour change that an identity can have only one capture now. Most use-cases involving a single finger/button likely already met this restriction.

If you capture multiple pointers and cannot easily switch to using ExtendCapture, you can also use a unique identity instead. Create a new object and use that identity as the second capture. This should work as it did before.

  • Added ExtendCapture to add additional points to an existing capture
  • Added ModifyCapture as a new high-level interface to the capture mechanism
  • Added Gesture to coordinate gesture support (experimental)
  • ReleaseAllCaptures renamed ReleaseCapture, since there can be only one
  • Removed Pointer.IsSoftCaptured and Pointer.IsHardCaptured in favour of just IsCapture.
  • The higher level PointerEventArgs still keeps many of the old entry points for compatbility/simplicity as it is more frequently used.
  • This deprecated package has been removed. If you for some reason depended on it, it can now be found here. Please note that this package is not actively maintaned nor supported. Use at your own risk ;)
  • The default setting for TextTruncation has changed from Standard to None. The Standard-setting is known not to work as expected on text-inputs, and the whole setting will probably be removed in an upcoming release. None of this applies to non-input controls.

Download this version

Fuse 0.35.0


  • The old Android installer has been replaced with the new android installer. Usage is still the same, in other words run fuse install android to install or update Android build dependencies.
  • Replaced the old gradle build system with a new system.
  • WebView now supports having a callback when the app's UriScheme is matched with an URL request.
New Android installer
  • The switch from gradle-experimental to standard gradle requires a new set of build dependencies, that have to be installed. fuse install android has been updated to make that process as pain free as possible. We encourage existing users to run fuse install android to update their environment.
  • Info to advanced users: The new installer doesn't depend on the sdkConfig.json, instead it only relies on .sdkconfig found here ~/Library/Application Support/Fusetools/Fuse/Android/.sdkConfig on macOS, or %LocalAppData%\Fusetools\Fuse\Android\.sdkConfig on Windows.
  • Fixed an issue where relative paths would be incorrectly resolved (against current path instead of intended actual path)
x and y UX expression functions
  • One can now get the x or y position of an element relative to its parent by using the x(element) or y(element) functions in UX expressions.
  • Added 'URISchemeHandler' callback, which fires when a URL request matching the app's UriScheme is made.
Foreign Objective-C
  • Uno has now enabled automatic reference-counting (ARC) in Foreign Objective-C code. If you have foreign code and Xcode complains about methods like dealloc, retain, release, or autorelease being unavailable, this can be fixed by removing the calls to those methods.
  • Color.ToRgb24, Color.ToRgba32, Color.FromRgb24, Color.FromRgb24, Color.FromRgba32 and Color.Rgba32FromHex, Color.ToHex(int3) and Color.ToHex(int4) have been marked as obsolete. See the obosletion-warnings for replacements.
  • Color.FromHex no longer accepts sign-characters in the hex-string. This wasn't intended to work in the first place, and only worked in some bizarre corner-cases.
  • Color.FromArgb and Color.ToArgb has been added.
Switch from gradle-experimental to standard Gradle
  • Using the -DGRADLE flag will now use the standard Gradle and CMake to build your projects.
  • Gradle will become the default build system in the next release and Ant support will be removed.

Download this version

Fuse 0.34.0


  • New <PlaySound> trigger for playing sound effects directly from UX markup
  • Configurable Android-themes (Material is now the default theme)
  • Improved performance and compatibility for images and camera
  • Smarter text wrapping in the Harfbuzz text renderer
  • The native Android-theme used by an app has been made configurable. Change the Android.Theme-property in your project-file to switch themes. The default theme on Android has been changed from the aging "Holo" theme to the new "Material" one.
  • To override the new default theme, add this snippet to your project file:
"Android": {
    "Theme" : "Holo"
  • Android: Improved memory use and performance when resizing images. This should improve Camera.takePicture performance as well, and prevent some OOM crashes
  • Fixed bugs in reading photo orientation from EXIF when reading RAW and JPEG files on Android
Camera and CameraRoll
  • Rewritten image fetch from camera capture and camera roll image picking activities for better Android device compatibility
Harfbuzz text renderer
  • The text renderer enabled by building with -DUSE_HARFBUZZ now uses an ICU BreakIterator to find out where to linewrap text, instead of just using spaces. This means that it properly wraps scripts (like Kana) that don't normally use spaces between words, and also means that it can wrap text after hyphens
  • The onReceivedMessage now provides an optional second argument which indicates whether the notification was triggered from the notification bar. You can use it like this: Push.onReceivedMessage = function(payload, fromNotificationBar) { .. }
  • Split the various launchers into their own packages so they can be used separately. They are named Fuse.Launcher.Email, Fuse.Launcher.InterApp, Fuse.Launcher.Maps & Fuse.Launcher.Phone
  • Fuse.Launcher is still available, and allow you to add all the above packages at once. This means that your current projects will keep working. However: to reduze the number of required permissions, simply add the specific package references for just the launchers you need to your project-file
  • Fixed issue where responses to requests for location permission were not correctly handled
  • Fixed a bug that lead to a crash on exit

Download this version

Fuse 0.33.2

  • Fixed an issue with .inner and .innerTwoWay forwarding the Observable itself
  • Fixed a bogus error when .expand was passed an empty Observable

Download this version

Fuse 0.33.1

  • Fixed a regression where observables would send multiple messages with the same value. This lead to unexpected behavior in some cases.

Goto https://www.fusetools.com/downloads/ to see the rest of the changelog for release v0.33.

Download this version

Fuse 0.33.0


  • Lots of Observable API improvements & cleanup
  • Performance improvements for native controls on Android
  • Low-level refactoring to enable A Brighter Future. Check this out if you write a lot of Uno code.
Native UI
  • Android: Improved the way fuse manages the native controls when using <NativeViewHost />. This resulted in big performance improvement in complex native UIs.
  • iOS: Fixed issue where autoscrolling in <TextView TextWrapping="Wrap" /> could misbehave if the TextView was in a Panel that let its size grow (like StackPanel)
  • Added Axis constraint to Draggable, allowing draggable behaviors locked to single axes if needed.
  • BusyTaskActivity.All has been removed, there is now a Common which covers the same tasks and a Any which covers all possible tasks.
  • Changed WhileFailed to be part of the BusyTask system. The biggest difference is that it will detect failures of any descendent elements, not just where it was used. This is unlikely to cause a behavioural change in most projects, but if you need the old matching use Match="Parent".
  • Removed the WhileFailed.Message resource. Add an error handler directly to the resource (such as ImageSource) if the error message is needed.
  • Data bindings now mark a node as failed if the observable produces an error, or the value cannot be property converted. WhileFailed will detect this failure.
  • Added the Busy behavior to help marking nodes as busy
  • Deprecated FuseJS/BusyTask, use the Busy behavior instead
  • Fixed an issue about certain text changes not propagating correctly
  • Added Observable.mapTwoWay: a two-way version of map
  • Added Observable.pickTwoWay: a two-way version of pick
  • Added Observable.innerTwoWay: a two-way version of inner
  • Fixed numerous issues with .inner(), however, if you relied on one of the abnormal behaviours it might be problematic. To assist in migration you can use .innerDeprecated() temporarily, which is the old way of doing .inner() (it will be removed eventually). .setInnerValue is also no longer available on .inner() (but still exists on .innerDeprecated), using a.innerTwoWay` and assigning a value is the new approach.
  • Deprecated .inner().twoWayMap() as it has numerous issues. The replacement is to use .innerTwoWay(), possibly combined with .mapTwoWay() which has a well defined behaviour.
  • Deprecated .beginSubscriptions and .endSubscriptions interface. These had issues that couldn't be resolved via this interface. If this causes any issues with your code then please get in touch and we'll work something out.
  • Added failedMap and isFailed to help track failure conditions
  • Failed Observables now lose any previous value. This was inconsistent before, sometimes they retained a value.
  • Failed Observables will clear the binding correctly now (for {Clear name} bindings)
  • Fixed a defect where onValueChanged would not respond to all changes
  • Fixed clearing of bindings when assigning an undefined value
  • Fixed forwarding of failed state in combine, combineLatest, and combineArrays
  • Fixed clearing of state if input undefined in combineLatest
  • State.On has been removed. This value should not have been public as it did not reflect a usable value, and could corrupt the current state. Use .Goto to goto the current state and StateGroup.Active to get, or set, the state.
  • Added ZoomEnabled attribute, defaulting to "true". In the past, zoom gestures were enabled by default on iOS but disabled on Android due to an oversight. This unifies the end-user experience.
  • Made Android WebView respect viewport tag and load content in overview mode to comply better with the iOS behavior.
  • We now catch exceptions that occur during processing of a selected picture in the iOS CameraRoll. In the past this could result in orphaned promises.
  • Added Completed trigger that pulses when a node is no longer busy
Xcode project generation
  • Added $(inherited) to the framework search paths, which is sometimes necessary when using CocoaPods.

Low-level changes

The following changes are only relevant if your project contains low-level Uno code or foreign code.


As mentioned in the changelog for Fuse 0.32, the following obsolete methods have been removed:

  • AutoResetEvent.Create()
  • ManualResetEvent.Create()
  • Mutex.Create()
  • Mutex.Lock()
  • Mutex.TryLock()
  • Mutex.Unlock()
  • Semaphore.Create()
  • Thread.Create()
  • Thread.Join(int)

If you still haven't updated your code to to match, you'll now get build-errors. See the changelog for Fuse 0.32 for upgrade instructions.

In addition, EventWaitHandle has been added as a base-class for AutoResetEvent and ManualResetEvent, and ConcurrentCueue no longer implements IDisposable, both similar to what .NET does.

  • Socket.Send(byte[], int, int) has been marked as obsolete. It doesn't exist (nor work) on .NET-targets. Use Socket.Send(byte[], int, int, SocketFlags) instead.
  • Socket.Receive(byte[], int, int) has been marked as obsolete. It doesn't exist (nor work) on .NET-targets. Use Socket.Receive(byte[], int, int, SocketFlags) instead.
Uno Refactor

A large amount of refactoring has been undertaken to solve two issue:

  • Enabling testing without GL
  • Moving the root-view code to fuselibs

This series of changes are seen as steps to enable where we want to go, we understand that things can feel a bit in-cohesive at this stage. But with these changes landed we will be able to iterate on the code bases more easily and fix some long standing issues (especially in areas such as system ui & fullscreen)

  • The new CoreApp class has been created. This is the new root application class instead of Uno.Application. It contains the lifecycle, Current & Load.

  • All platforms now feed lifecycle events through Platform.CoreApp

  • Uno.Application inherits from this and on desktop adds the GraphicsController and Window. Much of the Application class is deprecated for mobile targets. Window is still present for mobile but is deprecated for imminent removal.

  • GraphicsController is a class which holds much of the code that used to belong to GraphicsContext. It is only used on desktop. The reason for the change is that for mobile, everything in managed in fuselibs. GraphicsContext now exists as a handle.

  • A class called Displays had been added which contains a list of Displays. For now the most used field is MainDisplay, which for all current platforms is the only Display

  • A Display class now exists which holds the Density property & Tick event. There are subclasses of this iOS, Android & Desktop that handle the plumbing.

  • A class called OSFrame has been added which is the new base class of Window. As mentioned above, Window continues to be used on desktop & is deprecated on mobile.

  • Window contained far too many of the events. The EventSources namespace the new home for these migrated events. There are separate static classes for InterApp, HardwareKeys, Text & Mouse events. This separation will allow us to re-evaluate them separately and work on their future place in the API.

  • The mobile root-view bootstrapping is removed from Uno and moved to Fuselibs

  • SystemUI and it's bootstrapping is removed from Uno and moved to Fuselibs

  • Key events now have an Origin field, which is the OSFrame they originated from. This is for platforms where these events originate from Windows as opposed to UI elements

  • All core libraries that touched Platform2 events have been updated to use Platform rather than Platform2

  • Events which on some platforms are forbidden (like quit) now live in an class called Unsafe

Download this version

Fuse 0.32.0

  • WebSockets!
  • Added Page.Freeze and Navigator.DeferPageSwitch to deal with stutter and lag while navigating to new pages.
  • Revamped Uno.Threading for better performance and alignment with .Net APIs
  • Changes to how WhileCount handles multiple conditions.
  • Added support for WebSockets
  • Updated the bundled V8 engine to version 5.5 for Android, Windows and OSX Local preview.
  • Fixed some inconsistencies in how V8 handled marshalling Uno exceptions and String objects in JavaScript.
  • Added Page.Freeze that can be set to WhileNavigating to freeze the page (block updates) during navigation
  • Added Navigator.DeferPageSwitch to defer page navigation until the page is ready
  • Removed the static "State" events from Navigation, replacing them with INavigation.StateChanged. This should not affect any UX code, unless you used a WhileNavigating in an incorrect place, in which case you may get an error now.
  • Fixed Transition to work with swiping
  • Renamed NavigationControlBits to NavigationInternal -- these are not meant to be used and are only public for technical reasons
  • Fixed an issue of an incomplete back swipe causing oddness on the Navigator
  • Fix issue where Unrooting and then Rooting of a LinearNavigation could make the Active property hold an invalid object reference
Text rendering
  • Fixed an issue in the text renderer enabled by compiling with -DUSE_HARFBUZZ where center- and right-aligned text would not properly update their alignment when the text element changed size.
  • Fixed how multiple conditions were combined on WhileCount. Previosuly two conditions would be combined with "OR", now the various range combinations are combined with "AND". Refer to the docs on how to do an inverted, or "OR", range, and how to make a GreaterThanEqual or LessThanEqual comparison (this has changed in a backwards incompatible fashion)
  • Fixed some potential leaks and update paths on WhileCount
  • Added NodeGroup which allows combining several nodes and resources together in a block
  • Changed the ordering behaviour of how trigger actions/events are resolved. This resolves some issues with previously undefined behaviour. It should not affect applications unless they were inadvertently relying on such undefined behaviour. This generally relates to triggers with actions that modified their own state, or have a cycle with other triggers, or contain nodes but no animators.
  • WhileSwipeActive changed to be only active when the gesture is at progress="1". Previosuly this could activate immediately when the IsActive flag was switched, which led to inconsistent states. To get a behaviour close to the previous one set the new Threshold parameter to 0.01 (however, this is rarely desired).
  • Fixed a defect where a second swipe gesture might not have been recognized
  • Added WhileSwiping to detect an active swiping gesture
  • Added How="Cancelled" to Swiped to detect when the user does not complete a gesture
  • Added a IsFrozen feature that allows temporarily blocking any new layout as well as new drawing. It's meant to be used in conjunction with navigation for smooth transitions.
  • Several drawing and layout functions are now sealed. This prevents any derived class from implementing new layout, or drawing, which was never properly supported, and will fail now. You can instead derive from LayoutControl and override DrawVisual if necessary.
  • Fixed issue with duplicated items in Each using addAll
  • Fixed issue of refreshAll not removing excess items
  • Fixed issue of replaceAt not doing bounds checking
Xcode project generation
  • Xcode.ShellScripts are now escaped as string literals. No more fiddling with manual escaping.
Android builds
  • Added a JNI.SystemLibrary UXL element for linking in libraries like liblog.
Foreign Code Improvements
  • You can now make Uno properties where the bodies of the getter and setter are foreign code. For example:

      public int Foo
              return getSomeSubsystem().refreshRate;
              getSomeSubsystem().refreshRate = value;

    On foreign Java methods you can also provide annotations.

      [ForeignAnnotation(Language.Java, "TargetApi(19)")]
      public void Foo()
  • Fixed a bug where the argument names to foreign methods would be renamed because of other conflicting names in the same scope.

  • @{TypeName} macros now expand correctly in foreign Java & ObjC code.

  • The Uno.Compiler.ExportTargetInterop.Foreign.ObjC.Object class has now been removed. Use ObjC.Object instead.


To align better with the .NET APIs and to reduce some performance issues with our low-level threading API, we have revamped our API a bit. The following changes are noteworthy:

  • Thread.Join(int) has been marked as obsolete. It's not implemented on most platforms, so it's not very useful in its current form.
  • Thread.Create(), Mutex.Create(), Semaphore.Create(), AutoResetEvent.Create() and ManualResetEvent.Create() has been marked as obsolete. Use the constructors for the respective classes instead.
  • Mutex.Lock() and Mutex.TryLock() has been marked as obsolete. Use Mutex.WaitOne() instead.
  • Mutex.Unlock() has been marked as obsolete. Use Mutex.ReleaseMutex() instead.
  • Thread, Mutex, Semaphore, AutoResetEvent and ManualResetEvent are now sealed, and cannot be inherited from.

In order to get a smooth transition, the deprecated APIs are still present in the current release (but should produce compiler-warnings when used). They will however be removed soon.

Download this version

Fuse 0.31.2

Fixed missing file during Android deployment
  • Fixed missing Android package android support library during Android builds.
ux:Global in unreferenced class
  • Fixed a problem where ux:Global in an otherwise unreferenced ux:Class was never resolved correctly.

Download this version

Fuse 0.31.0

  • Reactive UX Expressions - achieve more awesomeness with less JS-glue-code required!
  • Several <Grid /> issues has been fixed
  • Router and Navigation improvements
  • Legacy Android and iOS Bindings removed
Data bindings no longer clear their value by default when removed
  • Data bindings used to clear (write null or 0) to their target properties when removed from the tree, so that old data would no longer linger if a node was reused later (manifesting as flashing of outdated data). However, this behavior lead to undesired consequences that were hard to work around in other cases. Now data bindings no longer clear by default.
    • This is unlikely to affect your app, but if you depended on the old behavior, you can restore the same behavior by using the new clear-bindings where needed: Change {foo} to {Clear foo}, and {Read foo} to {ReadClear foo}.
Observable bugfixes
  • Fixed bug where .twoWayMap() would not work correctly on boolean values.
Busyness and Transitions
  • Removed the public contructor and Done function of BusyTask. Only the static SetBusy function, and the JavaScript interface, should be used now.
  • Added BusyTaskActivity to note the types of busyness and added WhileBusy.Activity to match only certain busy activities
  • WhileLoading now uses the BuyTask system. The biggest difference is that it will detect loading of any descendent elements, not just where it was used. This is unlikely to cause a behavioural change in most projects, but if you need to old matching use Match="Parent".
Fixed data context bug with triggers and AlternateRoot
  • Fixed bug where nodes injected by triggers or AlternateRoot would sometimes not get the correct data context. This may break your app if you have a bug dependency. The rule is that nodes should always get the data context according to where they are declared in the UX tree, as you read it in the code (not based on where the node is ultimately injected, e.g. by AlternateRoot).
Introducing Reactive UX Expressions
  • All properties in UX markup now support reactive expressions, e.g. Width="spring({Property Size})" and Text="Hello, {username}!". For more details, see the documentation.
Text renderer
  • Improved the wrapping and truncation implementation with the text renderer that's activated by building with -DUSE_HARFBUZZ.
  • Added default font fallbacks on desktop when using the -DUSE_HARFBUZZ flag. This means that we can use emoji, many Asian languages, and Arabic in preview.
  • Fixed an issue that resulted in apps built using -DUSE_HARFBUZZ being rejected from the App Store due to referencing private symbols. This means that this flag can now be used in iOS releases.
  • Fixed a bug where TextInputActions did not trigger on desktop text inputs using -DUSE_HARFBUZZ.
Router and Navigation
  • NavigationGotoMode became a normal enum, not [Flags] and loses the ClearForwardHistory flag. Uses of that flag can be replaced with a call to ClearForwardHistory on the target navigation. Please see the documentation for more details.
  • Added the RouterModify action as a UX parallel to the JS .modify function
  • Added ModifyRouteHow.PrepareBack, PreparePush and PrepareGoto as ways to prepare for navigation combined with a swipe
  • Added the bookmark function to the router JavaScript interface
  • Added SwipeGesture.IsEnabled to allow disabling user interface
  • Added Navigator.SwipeBack that accepts a direction to enable backwards swipe navigation
  • Fixed the removal of pages with Reuse="None" in Navigator
  • TriggerAction.Direction has been replaced with TriggerAction.When. This includes the new Stop and Start option. The value Both has been replaced with ForwardAndBackward for clarity. Old UX code will continue to work.
  • iOS: Implement support for LineSpacing on <Text /> when used inside <NativeViewHost />
  • iOS: Implement support for LineSpacing on <TextView />
  • Numerous issues with Grid layout have been fixed. Unfortunately this changes how some existing grids might be arranged.

    • Proportional rows/columns now have no size when the grid is being shrunk to fit its contents. Previously they would have a minimum size related to their content; this value was actually incorrect, and caused other problems. This change fixes several layout issues with Grid.
    • A new metric called Default has been introduced as the default for DefaultRow and DefaultColumn. This maintains a behaviour similar, but not exactly the same as the old default. It is only usable for grids that fill a known space (or parent area), or have only 1 row or column. All other grids must set all Row/Column metrics correctly, or use DefaultRow and DefaultColumn.
    • The behavior of Grid's with cells containing RowSpan or ColumnSpan that extended beyond the intended bounds of the grid will now, more correctly, extend the grid instead of being clipped. Fixing the overflowing spans will restores the previous layout.
  • Added Grid.ChildOrder that allows changing whether children are ordered as rows or columns.

  • Removed the Column.ActualWidth and Row.ActualHeight properties. These were never meant to be publically readable as the value is not useful, nor guaranteed to be set.
  • Removed the public DefinitionBase.Implicit property. This has an ambiguous meaning and wasn't intended to be exposed publically (no valid use-cases)
  • The previously deprecated properties RowData and ColumnData have been fully removed. Use Rows and Columns instead.
Legacy Android and iOS Bindings Removed

As planned Legacy bindings are removed this release. Foreign Code is now the only official way of interfacing with native code.

Various changes
  • Building uno native, uno build native now works on Windows (will eventually replace uno build msvc)
  • Outdated Android solution for VS2015 removed

Download this version

Fuse 0.30.0

  • New, faster, text renderer, with better support for bidirectional text, ligatures and colored glyphs
  • New, simpler and safer event system for many FuseJS modules, such as Push, GeoLocation and more
  • Major clean-up, deprecating a lot of old stuff. This applies to the legacy iOS / Android bindings, out-dated build targets, importers and more. Please see the Deprecations section for details
  • Each now has Offset and Limit to limit the number of items being displayed
New text renderer

Added a new text renderer, which can be used for Text on both desktop and on device, and for TextInput/TextView on desktop. The renderer is currently disabled by default and can be enabled by building with -DUSE_HARFBUZZ. The new renderer brings the following features:

  • Support for complex text. The new text renderer can handle bidirectional text, ligatures, and colored glyphs.
  • Speed. The new text renderer is normally about 50% faster than the OS-specific text rendering we previously used on mobile devices, and can be up to 10x faster on some devices.
  • Asynchronous loading. Text elements now have an experimental LoadAsync property which, when set to true, enables loading of the text element on a background thread.

Note that the new text renderer currently does not pass Apple's App Store testing. Therefore it should not be used for iOS release builds. This will be fixed in an upcoming Fuse release.

FuseJS event system overhaul
  • The FuseJS modules that use events (GeoLocation, InterApp, LocalNotifications, Push, and Lifecycle) have gotten a new event subscription system. These modules are now instances of a class called EventEmitter, which is based on the API of Node's EventEmitter class. Though the old way remains working, the recommended way to subscribe to events has changed from Module.onSomeEvent = myHandler to Module.on('someEvent', myHandler). With the new event system there's no longer a risk of overwriting the handler that someone else set. There's also several convenience methods like once, observe, and promiseOf. Check out the docs!
  • Added Each.Offset and Each.Limit that allow limiting the number of items being displayed.
  • Fixed issues where certain route transitions would result in multiple active pages. This was a cache error that came up when using embedded Navigator objects and switching to/from the embedded pages.
  • Fixed issue where databinding to the same Observable on two different <TextInput/>s could end up in an infinite ValueChanged loop
  • Fixed issue where tapping a <TextInput /> in an area outside the bounds of the text would not focus the <TextInput />
JavaScript implementations
  • Optimised passing Uno byte[]s to and from JavaScript when running on iOS 10 using newly available functionality in the JavaScriptCore framework. The performance of this operation under iOS 10 now more closely matches the other JavaScript engines.
  • Fixed bug in btoa, atob implementation.
  • Fixed issue "Uncaught ReferenceError: setTimeout is not defined" that appeared in some cases.
  • Fixed memory leak in V8 when using HTTP.
FuseJS/Base64 module
  • Exposed functions encodeLatin1 and decodeLatin1.
  • Added decodeBuffer and encodeBuffer functions to decode between ArrayBuffer and Base64
  • Removed SetModuleFunction from the NativeModule interface. Use Module.CreateExportsObject instead.
  • Added Uno.Net.Sockets.TcpListener helper-class for hosting TCP servers. It's a subset of .NETs System.Net.Sockets.TcpListener class, and resolves to that implementation for .NET-targets.
Uno Syntax sugar
  • Three new literal types are added in Uno: Points, pixels & hex color codes.
#000         float3(0,0,0)
#FFFF        float4(1,1,1,1)
#FF0000      float3(1,0,0)
#FF0000FF    float4(1,0,0,1)
24.0px       new Uno.UX.Size(24.0f, Uno.UX.Unit.Pixels)
32.0pt       new Uno.UX.Size(32.0f, Uno.UX.Unit.Points)
Deprecation of Legacy Bindings

Before Foreign Code there was Bindings. The bindings were an attempt to bring Android and iOS functionality into Uno based on the best practices of the time. During the course of the implementation we found many shortcomings with those approaches and this eventually culminated in the creation of Foreign Code (see this medium article for the full story).

Foreign Code has since proved it's worth, it handles all that our Legacy Bindings could and plenty more.

Since January we have put forward Foreign Code as the standard way of interacting with native APIs, and a couple of releases back we officially deprecated the legacy Bindings.

The next release of Fuse will not ship with the legacy Bindings.

While foreign code is the way to go these days we understand that there might still be codebases out there based on the Bindings. If this affects you then feel free to reach out to us, we are happy to offer advice on how you can refactor to foreign code.

Deprecation of build targets

The following build targets will generate a warning if used:

uno build webgl
uno build ffos

We're deprecating build targets based on JavaScript & WebGL exports because our JavaScript backend is no longer maintained. (Note: this has absolutely nothing to do with the use of JS in your mobile apps - that'll still work as before.)

Deprecated packages
  • Quite a few packages and classes have been marked as obsolete. This means that they are still available, but will produce warnings on use. In a future release, these may get removed fully.
  • The packages Fuse.Drawing.Batching, Fuse.Drawing.Meshes and Fuse.Entities, as well as the classes Cube, WireCube, SolidCube, Cylinder and Sphere from Fuse.Drawing.Primitives and Trackball from Fuse.Gestures have been marked as obsolete. This is undocumented code that implement very basic 3D rendering, but haven't been in use for a long time, and is largely unmaintained at this point.
  • Fuse.Drawing.Polygons, Fuse.Drawing.Paths as well as Ellipse, Path, Star and RegularPolygon from Fuse.Controls.Primitives has been marked as obsolete. This is either undocumented code that implement very basic path-rendering, but is known to be broken in many simple cases, and is largely unmaintained at this point.
  • To avoid that new code accidentally starts using the above code in the case where the user doesn't notice or ignores the warnings, Fuse.Drawing.Paths, Fuse.Drawing.Polygons and Fuse.Entities no longer gets forwarded through the Fuse-package. If you're using one of these, you can add these packages manually to your project while transitioning.
Deprecation of importers

The following will now generate a warning if compiled:

import Uno.Array<T>()
import Uno.Buffer()
import Uno.Content.Fonts.FontFace()
import Uno.Content.Fonts.SfdFont()
import Uno.Content.Fonts.SpriteFont()
import Uno.Content.Models.Model()
apply Uno.Content.Models.Model()
import Uno.Graphics.IndexBuffer()
import Uno.Graphics.Texture2D()
import Uno.Graphics.TextureCube()
import Uno.Graphics.VertexBuffer()

These APIs are scheduled for removal in an upcoming release, because we no longer want to maintain dependencies to the proprietary FBX SDK from Autodesk in our core product.

Download this version

Fuse 0.29.0

  • Introduced <Transition> allowing for fine-tuning transitions between pages in Navigator.
  • Fixed signing of Android apps on Windows when building with Gradle
  • Initial support for Swift by calling it through Objective C. (Writing foreign Swift directly is not supported yet.)
  • Fonts can now be loaded from the target device so they don't have to be bundled with the app
  • Using Gradle builds, you can now finally preview and export for Android even if you have spaces in your paths! Wohoo!
  • Introduced <Transition> allowing for fine-tuning transitions between pages in Navigator. Please see the documentation for details and examples.
  • Fixed an issue with spaces in paths when doing preview and export for Android
  • Fixed an issue when signing Android apps on Windows
Support for adding Swift files to unoprojs

Added Swift file type to unoprojs. Swift files currently do not get the foreign macro expansion that ObjCSource files benefit from.

Set the desired Swift version (it currently defaults to 3.0) with the iOS.SwiftVersion project property, like this:

"iOS": {
  "SwiftVersion": 3.0,

The following example shows how to use this feature:


import Foundation

public class HelloSwiftWorld: NSObject {
    public func hello() {
        print("Hello world!");


    "Includes": [


Since Swift can be used from Objective-C, we can call into the Swift code by using Foreign Objective-C, for instance like this:

[ForeignInclude(Language.ObjC, "@(Project.Name)-Swift.h")]
public class Example
    public static void DoIt()
        HelloSwiftWorld* x = [[HelloSwiftWorld alloc] init];
        [x hello];
  • Added SystemFont which is a subclass of Font that gets fonts from the target device so they don't have to be bundled with the app.
  • iOS: Fixed an issue where iOS 10 apps would crash during font loading.
  • {Property } bindings now supports automatic conversion (bindings) between weakly compatible types, such as float and Size.
  • Added {SnapshotProperty ...} which is a read-once property binding that reads the value at rooting time but does not listen for changes in the property.
  • Moved PropertyBinding from Fuse.Controls to Fuse.Reactive (might break Uno code and cached code, remember uno clean)
  • Fixed a crash that could occur when doing two-way data-binding to enum values.
  • Introduced Element.ExplicitTransformOrigin that allows setting a location for the TransformOrigin
  • Added the ability to use non-template pages to Navigator
  • Added PageView, which is a Navigator without any standard transitions or page effects
  • Added a JavaScript interface to the NavigationControl (base type of Navigator and PageControl). This adds the gotoPath and seekToPath functions.
  • Added Each.Offset and Each.Limit that allow limiting the number of items being displayed.
  • Fixed a crash that could occur when data-binding to the Rows/Columns property of a grid.
  • Android: Fixed issue where <Circle /> inside <NativeViewHost /> could end up not displaying.
  • Fixed a null value exception when binding a value to SolidBrush.Color
  • iOS: Fixed a bug in Video where calculating rotation could result in glitches due to a rounding error.
  • Added RelativeScrollPosition to ScrollPositionChangedArgs
  • Added serialization of value (the scroll position) and relativePosition to JavaScript for ScrollPositionChangedArgs
  • Unsealed DropShadow, making it possible to create ux:Classes of DropShadow
  • iOS: Fixed issue where having a <NativeViewHost /> inside a <PageControl /> would not handle input events properly
  • Implemented forwarding of HitTestMode to the native view for elements inside a <NativeViewHost />
  • Added <ImageFill WrapMode="ClampToEdge" /> to restore old, clamped rendering of the texture. This is useful if you're just using an ImageFill to mask an image with a circle or something along those lines.
  • Added support for WhileBusy and WhileLoading while using an ImageFill brush inside a Shape
  • Changed Tapped to be an attached event, which means handlers can be created by doing <Panel Tapped="{onTapped}" /> instead of <Panel><Tapped><Callback Handler="{onTapped}"/></Tapped></Panel>.
  • Android preview and export now works for users with spaces in their paths, as long -DGRADLE is used. Note that for this to work with preview, you have to specify the .unoproj explicitly: fuse preview -tandroid my.unoproj -DGRADLE.
Source value warning
  • Fixed the source value 1.5 is obsolete and will be removed in a future release warning.
  • Visual.ParentToLocal has been replaced with TryParentToLocal. It's possible that this function can fail, even under common use, thus it's important callers detect that condition.
  • Visual.FirstChild<T> now searches for the first child, not the last child as it previously did. If you depended on the old behavior, you can manually traverse the Visual.Children list backwards, and search for the child.
  • Android: Fixed a crash that could occur when receiving two notifications at the same time.
Event handlers
  • Fixed a bug where some event types (e.g. <Activated>) would fire the old version of an event handler when a page is navigated to multiple times.

Download this version

Fuse 0.28.1

This is a hotfix release that fixes a crash in Video on Android 4.3 and below, which was introduced in 0.28.

Download this version

Fuse 0.28.0


  • Fixed an issue in preview on macOS Sierra where ScrollView would misbehave and scroll too slowly.
  • Added router.modify to the JavaScript interface. This function can be used to provide more routing options, such as "Replace" mode and "Bypass" transitions.
  • Added CubicBezierEasing which allows you create custom easing curves with two control points.
  • A proper navigation interface is now implemented on Navigator. This allows Page bindings to work for the active navigator page, such as {Page Title}.

But there's so many smaller and larger updates this time that you should totally read the full list!

iOS 10
  • Fixed an issue with Promises resulting in an error: "Invalid private name '@undefined'"
  • Fixed an issue on Android & iOS where <TextInput> could be seen for 1 frame on screen when it was supposed to be hidden / behind other visual elements.
New Instance behavior
  • Introduced <Instance>, which instantiates ux:Templates. Equivalent to <Each Count="1">, but reads better in UX and doesn't expose Count or Items.
  • Uno level: Extracted base class Instantiator from Each, which Instance also inherits.
Android Notification Icon

Users of Local & Push notifications on Android can now specify the icon to be used for the notification. This is done in the same fashion as the regular android icons. In your project's unoproj specify:

        "Android": {
            "NotificationIcon": {
                "LDPI": "Icon-ldpi.png",
                "MDPI": "Icon-mdpi.png",
                "HDPI": "Icon-hdpi.png",
                "XHDPI": "Icon-xhdpi.png",
                "XXHDPI": "Icon-xxhdpi.png",
                "XXXHDPI": "Icon-xxxhdpi.png"

The icon must adhere to the Android style guides. In short it must be white on a transparent background, any solid color will be converted to white by the Android build process, something which is outside of Fuse's control.

The behavior around default notification icon has also changed. Before we simply used the app icon. This meant that when the icon had color, the color was removed by android often resulting in an white square. With this change we will either:

  • Use the Android.NotificationIcon as specified above. Or if that is not specified we...
  • Use the Android.Icons setting from your unoproj. Or if that is not specified we...
  • Use the default notification icon, which is a small white Fuse logo.
Observable improvements
  • Added .subscribe(module) which can be used to create a dummy subscription on observables for the lifetime of the given module. This is an alternative to adding the observable to module.exports or using .onValueChanged in cases where you want to access the observable's value in a callback.
Layout info in JS
  • The Placed event now provides metadata to its argument to let you know more about the layout of an element in JS: .x, .y, .width and .height. Usage:
    function panel_placed(args) {
        args // contains information about the new size and position 
<Panel Placed="{panel_placed}"/>
Pointer events in JS
  • Added localX and localY to pointer events in the JS API. This is the coordinate in the local coordinate space of the element that the event occurred on.
  • Added support for rotation defined in the metadata of the video source. Only supported on iOS, Android and OSX. Due to a limitation in the Windows implementation this won't be supported on Windows for a while.
Easing improvements
  • Refactored Easing from an enum into a base class, to allow custom easing curves. (UX interface unchanged, Uno code should also be mostly unaffected).
  • Added gotoRelative and pushRelative functions. These allow relative changes in route without needing to specify the full absolute path.
  • Fixed <Shadow> so it still draws the shadow-rectangle when the element's color contains zero-alpha.
  • Fixed the Softness-parameter so it looks consistent across different display densities.
  • <Shadow> elements now understand that it's not always hip to be square! They'll now draw a round shadow rather than a rectangular one if their parent is a <Circle>
Support for resources in triggers
  • Triggers can now have resource nodes (marked with ux:Key) inside, and they will be added to the parent node when the node is active. This allows e.g. per-platform or conditional styling.


    <Font File="foo-ios.ttf" ux:Key="DefaultFont" />
    <Font File="foo-android.ttf" ux:Key="DefaultFont" />
<Text Font="{Resource DefaultFont}" />
  • Added Container panel which allows you to build custom containers where children are placed under a custom node deeper in the tree.
  • Added native support for Color on <Image>es that are inside <NativeViewHost>
  • Fixed an issue where <Image> inside <NativeViewHost> would be laid out wrong
Native views
  • Fixed issue where ZOrdering inside <NativeViewHost> did not behave properly
One-way data binding
  • Added one-way (read-only or write-only) binding types: {ReadProperty prop}, {WriteProperty prop}, {Read data} and {Write data}
  • Removed ActionStyle from <TextView>. This is a <TextInput> specific property and it did not have any effect on <TextVIew>
  • Fixed iOS issue where AutoCorrect suggestions would not trigger value changed events if a <TextInput> or <TextView> lost focus.
  • Fixed issue where assigning a string with newlines to a <TextView TextWrapping="Wrap" /> would fail to wrap the text.
  • <ImageFills> now repeat the texture if a StretchMode like PixelPrecise or PointPrecise is used.
  • Fixed issue where animating TextColor did not presever the right init value
Image loading
  • Fixed a crash-bug when loading certain images on iOS
Added more control of PList in unoproj

We have added option to specify the following iOS plist entries from the unoproj file:

  • NSCalendarsUsageDescription
  • NSPhotoLibraryUsageDescription
  • NSBluetoothPeripheralUsageDescription
  • NSCameraUsageDescription
  • NSMicrophoneUsageDescription
  • NSAppleMusicUsageDescription
  • NSContactsUsageDescription
  • NSHomeKitUsageDescription
  • NSLocationAlwaysUsageDescription
  • NSLocationUsageDescription
  • NSLocationWhenInUseUsageDescription
  • NSMotionUsageDescription

They can be used as follows:

"iOS": {
    "PList": {
        "NSCameraUsageDescription": "ReasonA",
        "NSMicrophoneUsageDescription": "ReasonB",
        "NSPhotoLibraryUsageDescription": "ReasonC",
Foreign Code

Foreign Java is a little more strict and does a little more type checking during the build.

  1. Action<object>s passed to Java will now have the type Action_UnoObject rather than Action_Object Action<Java.Object>s passed to Java will still have the type Action_Object
  2. If you make a foreign method with an argument with type object. You must pass an Uno object, not a java object.

Here is an example for point 2 that will no longer compile:

static string Foo()
   Object jobj = MakeSomeJavaObject();

static string Bar(object x)

The fix for the above would be to change Bar(object x) to Bar(Java.Object x) and @{Bar(object):Call(jobj)} to @{Bar(Java.Object):Call(jobj)}

Gradle Support
  • We can now build signed APKs with Gradle.
  • For users who run into platform specific filepath length limitations whilst build for Android with Gradle, you can now use the --set:AltBuildPath="/tmp" argument to specify the root of your android builds.
Xcode project generation and signing
  • Fixed a crash occuring when running multiple test fixtures on iOS devices
UX Compiler improvements
  • Binding syntax is now supported in shorthands such as <Change foo.bar="{binding}" /> and similar (bugfix).
  • Fixed bug where Font and other types that have required UX attributes (constructor arguments) could not be used as ux:Property

Download this version

Fuse 0.27.1

This is a hotfix release that fixes two bugs that were introduced with Fuse 0.27:

  • Fixed an issue where textures could become corrupt if uploaded async on Nvidia Tegra K1 class GPUs
  • Fixed an issue where the presence of android build tools version 20.0.0 prevented building for Android

Download this version

Fuse 0.27.0

  • Changes in how router parameters are handled - to avoid unwanted animations and unnecessary reinitialization.
  • Automated iOS project signing so you won't need to set it manually in Xcode every time you export from Fuse.
  • Deprecation of the old native bindings. Long live foreign code!
  • Faster Android preview builds.

.. and a lot of other goodies!

  • Improved build times for Android preview. As an example, the example template that ships with Fuse can be expected to build around 20-25% faster. Note: the speedup is constant, meaning that it's most noticeable on smaller projects.
  • Fixed an issue where PulseTrigger.Handler didn't work in preview. This caused errors like Type not found: Fuse.Triggers.ScrolledArgs and Type not found: Uno.EventArgs>.PulseHandle.
  • Unsealed lots of Trigger classes making it possible to create useful ux:Classes of them.
  • Added the WhileVisibleInScrollView trigger that is active when an element is positioned in, or near to, the visible area of a ScrollView.
Router and Navigator
  • To avoid problems with default routes and unintentional parameter differences, several default and empty-like parameters are now considered the same in Navigator. These are Uno null and empty string as well as JS null, empty object, and empty string. If these change only a "minor" page change is activated, which will cause an onParameterChanged handler to be called, but does not invoke animation by default.
  • Router will now give error if functions or observables are passed as route parameters (instead of silently failing). Route parameters must be serializeable as they are stored between refreshes in preview.
  • Fixed issue where using a <GraphicsView /> inside <GraphicsView /> and using it on desktop would crash the app
  • Fixed issue where newline characters would not be escaped correctly when using Json.Stringify from Uno.
  • Implemented support for Volume in <Video /> on OSX preview
  • Fixed null ref that could trigger if databinding Progress on <Video /> to JavaScript
  • Fixed an ordering issue with triggers and adding children. This was a hard to get defect that resulted in some trigger actions, such as in Navigator, not being activated correctly when the child is first added.
JavaScript cleanup
  • Cleaner debugging: Reduced the amount of duplicate utility scripts compiled by the JS context, showing up in some JS debuggers (e.g. Safari).
  • Made Fuse.FileSystem.Nothing, Fuse.FileSystem.FileSystemOperations, Fuse.FileSystem.BclFileInfo and Fuse.FileSystem.BclFileAttributes internal, as they were marked as public by mistake.
  • Fixed bug where an unfocused <TextInput /> would not render RTL text correctly
  • Fixed bug where the SoftKeyboard would not appear on screen when <TextInput /> gets focused while in Landscape
  • Fixed getImageFromBase64 on Android
  • Effects are now Nodes, and can as a result be contained inside triggers.
  • Element.Effects is no longer accessible. The new way of adding effects, is to add them to Element.Children, like other Nodes.
  • Element.HasEffects, Element.HasActiveEffects and HasCompositionEffect are no longer accessible. These were only meant as helpers for the implementation of Element, and shouldn't be needed elsewhere.
Xcode project generation and signing
  • Added a property to set the Xcode Development Team ID, used for code-signing, in unoprojs:

        "iOS": {
          "DevelopmentTeam": "YOURTEAMID"

    This property can also be set using the --set:Project.iOS.DevelopmentTeam="YOURTEAMID" flag to uno build, e.g.

      uno build iOS --set:Project.iOS.DevelopmentTeam="YOURTEAMID"

    The Team ID can be found at https://developer.apple.com/account/#/membership/.

  • The Development Team ID can also be set user-wide by adding the following to ~/.unoconfig:

      iOS.DevelopmentTeam: "YOURTEAMID"

    The file can be created if it doesn't already exist.

  • Uno now attempts to automatically find a Development Team ID if it hasn't already been set using either of the above methods. It does so by querying the machine's code-signing identities and selecting the first valid one it finds.

Foreign code
Foreign Java Bugfix
  • Fixed bug causing build error when returning structs from foreign Java Code
Expand on using Uno arrays from Foreign Java
  • Can now pass Uno unsigned byte arrays to foreign Java
  • Add ability to make boxed Uno arrays from Java You can now create Uno arrays in Java. To do this you make a new instance of the boxed array types passing in either:
    • the desired length of the Uno array
    • the Java array you want to convert
LongArray ularr = new LongArray(100);
IntArray uiarr = new IntArray(new int[]{1,2,3});

The length constructor works on all the following types. The Java array conversion works on all except the types marked with a *

  • BoolArray
  • ByteArray
  • CharArray *
  • DoubleArray
  • FloatArray
  • IntArray
  • LongArray
  • ObjectArray *
  • ShortArray
  • StringArray *
Old bindings
  • The following packages have been deprecated, and will be removed in an upcoming release. Code using these packages can be re-written in foreign code.
    • Experimental.iOS
    • ObjC
    • Android
  • Removed PlaceholderText and PlaceholderColor from <TextView />. These properties did not belong on <TextView /> in the first place and was never properly implemented across platforms. Semantically <TextView /> is just a viewer and editor for large amounts of text. If you need a placeholder it should be implemented in UX, for instance like this:
    <WhileString Test="IsEmpty">
        <Text TextWrapping="Wrap">My Placeholder</Text>

Download this version

Fuse 0.26.0

  • Lots of new features for working with Observables
  • New Selection API
  • Custom map markers
  • New, highly performant Shadow tag, which can often replace the slower DropShadow
  • A number of bug fixes dealing with anything from crashes to statusbars that just wouldn't take no for an answer!
  • The inspector has been retired.
Observable improvements
  • Added .addAll(), .insertAll() and .removeRange() for faster list manipulation
  • Fixed bugs in .where() and .count() dealing incorrectly with some operations
  • .where() and .count() now supports objects as filters, e.g. list.where({id: 4})
  • Added .any( [criteria] ) which returns an observable boolean of whether the observable contains an object that meets the criteria.
  • Added .first( [criteria] ) and .last( [criteria] ) which returns an observable of the first/last item that meets the criteria, or simply the first/last element if the criteria is omited.
  • Added .identity(), .pick() and .flatMap()
New Observable.inner() superpowers to ease two-way bindings on ux:Property
  • Two-way data bindings are an experimental feature and their exact form and syntax may still change significantly.
  • On observables returned by .inner(): support for .twoWayMap() to ease construction of components with two-way bindable properties. For example usage, see https://github.com/Duckers/FusePlayground/tree/master/Components/DateEditor
  • On observables returned by .inner(): support for .setInnerValue() which sets the value of the inner observable without sending a message back to the observable returned by .inner(). When creating a component with a two-way bindable property, this should be used to notify users of the component that a property has been changed from within the component, typically driven by user interaction.
  • Fixed initial value race condition in implicit observables for ux:Property causing unpredictable behavior
  • BREAKING CHANGE: An ux:Property of a class type (e.g. object or Brush) with value null in Uno will now produce an empty observable Observable() instead of Observable(null) in JavaScript. This prevents a lot of annoying scenarios where e.g. map() will unexpectedly map null instead of a real value (often leading to crash). When the Uno side is null, obs.value will now be undefined (as the observable is empty, length=0). This might have backwards incompatible side effects if you relied on null being set.
  • Added the Selection API, comprising Selection, WhileSelected, ToggleSelection, Selectable, Selected, and Deselected. As this is a new feature the API may still undergo some minor changes in the upcoming releases.
  • You can check out this pizza ordering example to learn more. (Mmmmm pizza!)
Inspector removed

The Inspector was intended as a proof-of-concept and testing ground for some of our ideas around visual tooling. It has now overstayed its welcome, been a fairly low priority for a while (and contained a few long-lived bugs) so we finally decided to remove it. We will however take what we learned from it and be back with much cooler visual tools in the future! :)

New ScrollView features
  • Added Scrolled and WhileScrolled triggers which respond to scrolling within a region of the ScrollView. These provide more flexibility e.g. for dynamically loading more data in an infinite feed (compared to WhileScrollable).
  • Added LayoutRole="Placeholder" to create items that are part of a ScrollView or Navigation's layout but not a logical item (like page, or scroll anchor). This is an experimental feature and it's behaviour may change in future releases.
  • DeriveClone renamed CloneAndDerive and TrueClone renamed Clone to help avoid confusion about what they do.
  • Added LinearRangeBehavior.Orientation to allow vertical range controls
  • WhileNavigating changed to a WhileTrigger to add Invert functionality
  • Fixed issue so WhileNavigating now finds ancestor navigation
  • MapMarker now has an IconFile attribute, letting you specify a file asset to replace the marker icon graphic.
  • Added IconAnchorX and IconAnchorY attributes to MapMarker. These are normalized coordinates from 0,0 to 1,1 determining the point on the icon graphic where it rests on the map. This defaults to 0.5, 0.5, being centered.
  • Fixed an issue that caused a crash on iOS when used together with FuseJS/GeoLocation package
  • Improved the iOS implementation of GeoLocation. The most significant changes are that getLocation now respects its timeout parameter, and that multiple concurrent calls to getLocation are handled gracefully.
  • Fixed issue where location fetch requests on Android would run on the wrong thread
  • Fixed some issues to ensure the resulting children order matches the logical UX order of Each Match and Deferred. This affects code where these triggers are used directly inside each other without an intervening Panel (adding that Panel was the previous workaround).
  • Fixed an issue where the content in an Deferred was not removed while unrooting the Deferred
  • The previous reactive Select trigger has been renamed With to better reflect what it does and not cause confusion with the selection API.
  • Added WhileString, a WhileTrigger that tests conditions on a string value.
  • Optimise string handling by avoiding needless conversions back and forth to UTF-8.
Native views
  • Images inside <NativeViewHost /> can now have URL-sources with <Image Url="..." />
  • Fixed a crash due to unhandled types passed to the JavaScript VM.
  • Fixed a crash while trying to re-bind data-bindings on unrooted nodes.
  • Fixed a bug where databinding to outer data contexts often failed due to a race-condition
  • Fix problem getting dataDirectory and cacheDirectory while running with fuse preview
  • Added a Shadow-tag that is generally a faster alternative to DropShadow. It works by approximating the background of a rectangle by applying a gradient on the distance field of a rectangle instead. This only works well for rectangles and panels, but has a Mode-property that can be set to PerPixel (instead of it's default, Background) to get the same effect as with DropShadow.
  • Fixed a bug, where setting IsVisible on Android.StatusBarConfig accidentally also had effect on iOS.
  • Fixed Android issue where the StatusBar visibility would be reset whenever the softkeyboard is onscreen. The visibility is restored when the keyboard is dismissed


  • The content of AlternativeRoot can now be any class that inherits from Node, not just a Visual.
Input Handling
  • Fixed a crash due to a null-pointer reference while handling input-events
Xcode project generation
  • We now add the directory of Required Xcode.Frameworks and Xcode.EmbeddedFrameworks to Xcode.FrameworkDirectory, meaning that Xcode.FrameworkDirectory will rarely be necessary to use.
  • Fixed marshalling of GCM push notifications, caused by change in protocol
  • Moved declaration of attached property Friction from Fuse.Physics.Body to Fuse.Physics.BodyAttr. No UX changes are required.
  • Moved declaration of attached properties LayoutMaster and ResetLayoutMaster from Fuse.Elements.LayoutMasterBoxSizing to Fuse.Elements.LayoutMasterAttr. No UX changes are required.
  • Element.OnDraw has slightly changed meaning. It used do draw both the element itself and it's children (which was implemented in the base-class). Now it just draws the element itself. Instead, we have a new method called Element.DrawWithChildren that will call Element.OnDraw and then draw the children. This was done to accomedate Layer.Underlay, which required the base-class to draw some things both before and after the element itself was drawn. If you want to avoid drawing the children under some circumstances, override this method instead of Element.OnDraw.

Download this version

Fuse 0.25.5

Fixed an issue where location fetch requests on Android would run on the wrong thread, sometimes resulting in a crash.

Download this version

Fuse 0.25.4

This release fixes a problem on OS X where some users got the error The type initializer for 'System.Drawing.GDIPlus' threw an exception when building for Android or iOS

Download this version

Fuse 0.25.3

Hotfix for 0.25.2: Fixed issue in 0.25.2, which caused build errors when targeting iOS, on some setups.

Download this version

Fuse 0.25.2

This release fixes a problem with high CPU usage in preview on OS X. Many apps would use one core when idling in local preview.

If you're not on OS X, or you're not affected by this bug, you can safely skip this release.

Download this version

Fuse 0.25.1

This is a bugfix release that fixes the following:

  • An issue in some older Android versions, where the OpenGL context would be leaked under som circumstances has been worked around. This problem manifested itself as images seemingly randomly being swapped.
  • Fixed an issue where fuse preview would sometimes fail with unzip: cannot find or open (...) the first time it was run after Fuse was installed/upgraded
  • Fixed an issue where the this.Parameter observable in a JS module would not behave properly when a <Navigator /> reused pages
  • Fixed an issue in the example project where page 2 did not react on touch input
  • Fixed a crash when setting Image.Source to null when inside NativeViewHost
  • Fixed a problem getting dataDirectory and cacheDirectory while running with fuse preview
  • Fixed an issue where the some parts of the Monitor UI would not display, or not resize correctly
  • Fixed an issue that hit people who upgraded from a more than a year old version of Fuse to a recent build. They were not able to build for Android, getting an Access denied message.

Download this version

Fuse 0.25.0

NOTE: After upgrading to Fuse 0.25 it is necessary to re-run the command fuse install android to be able to deploy to Android devices

  • New FileSystem module
  • Faster incremental builds
  • Several new triggers, especially related to navigation
  • Added new JS FileSystem module with several new features. This will eventually replace the Storage module. You can find a file browser sample using it here.
  • Known issue: dataDirectory and cacheDirectory do not work as intended in local preview, and place the directories besides Fuse.exe instead of the project build directory.
Improved incremental build
  • fuse build / uno build won't trigger a build if the previous one is still up-to-date
  • Automatically removes outdated files and APK from Android builds
  • Added trigger Activated, fires when a navigation page becomes active
  • Added trigger Deactivated, fires when an active page becomes inactive
  • Added event INavigation.ActivePageChanged
  • The navigation animations ExitingAnimation, EnteringAnimation, ActivatingAnimation, and DeactivatingAnimation now delay their animation start by 1 frame. This avoids first frame setup costs from interfering with the animation. This does not apply to seeking page progress, like swiping, or standard navigation in a PageControl.
Minimum sdk version

In the current release the default minumum sdk version for android builds has been set to 16. This corresponds to Android 4.1, which is the oldest version we're currently testing for. However, for those who wish to continue building for older versions of android you and simply add the following to your unoproj file

"Android": {
   "SDK": {
         "MinVersion": "10"

or, if you prefer, you can use the following command line argument:


Because of this change it is necessary to re-run the command fuse install android after installing Fuse 0.25 (if you want to be able to deploy to Android).

FuseJS require
  • Added support for the require('./directory') pattern when directory/index.js exists to support more node packages.
  • Added a mobileOSVersion property to FuseJS.Environment to give access to the Android and iOS OS version at runtime.
Databinding stability fix

Breaking change: databindings no longer resolve to data(e.g. <JavaScript />) local to the node, only to parent inherited data. This solves common problem scenarios where you would get cyclic databindings leading to memleaks and crash. This means the following will not work anymore:

<Panel Width="{foo}">
        module.exports.foo = 10;

If you depend on this behavior it can be written as:

<Panel ux:Name="p">
          module.exports.foo = 10;
        <DataBinding Target="p.Width" Key="foo" />
Xcode project generation

Added a new property to set the UIBackgroundModes property of the generated Xcode project. You can use it by adding the following to your .unoproj:

"iOS": {
  "PList": {
    "UIBackgroundModes": [
Deferred node creation
  • The Deferred class has been introduced to help keep UIs responsive when a lot of new nodes are added at the same time. Read more about it here.
  • Added support for IsEnabled for elements inside <NativeViewHost />
  • unoproj: Allow - in version strings
  • Fixed crash in ProcessExtensions on Windows
  • Fixed issue where onscreen keyboard could randomly appear when using WebView in NativeViewHost
  • Fixed WebView issue where databinding on HTML.Source didn't compile
  • V8: Cleaned up how exceptions that cross the Uno-JavaScript boundary work. The exception on the JS now contains information about the Uno exception, and if the exception is not caught in JavaScript and rethrown in Uno, the exception contains both Uno and JavaScript stack traces.
Foreign code bugfixes
  • Fixed a bug that meant fields accessed using macros that didn't use :Get() in foreign Objective-C, such as @{MyClass:Of(_this)._someField}, did not have their types converted from Uno to their Objective-C equivalents
  • Fixed a bug that resulted in foreign code in static constructors not working
Native views bugfixes
  • Fixed issue where Circles with Strokes would not display correctly on iOS
  • Fixed issue where inputevent sometimes would not come through when tapping on native iOS and Android buttons
Uno parser reimplementation

Faster & harder parser that comes with some minor breaking changes to the syntax.

Previously, some invalid variable declarations were accepted:

var a = 0, b = 0;           // Invalid 'var' with multiple declarators
var c = fixed int[] {0};    // Invalid 'var' with fixed array

The correct syntax is:

int a = 0, b = 0;           // OK
fixed int c[] = {0};        // OK

Download this version

Fuse 0.24.0


  • Fix issue where the ValueChanged on <TextInput /> would fire when the textinput lose focus on iOS
  • Worked around an issue where TextInput controls were slow to activate the first time it's done when debugging an app using Xcode.


  • Cleaned up object lifetime bugs related to multiple <JavaScript> tags in the same ux:Class.
  • Fixed bug where bundled modules evaluated every save when required with ".js".
  • onValueChanged subscriber lifetime cleanup
  • Observable/parameter subscriber lifetime cleanup
  • Observable.onValueChanged(module, callback) - now expects module as first argument to tie the subscription to the lifetime of the module. Omitting the argument will still work but is deprecated and will leak.
  • this.onParameterChanged(function(param) {..}) deprecated (leaky). Use the new `this.Parameter.onValueChanged(module, function(param) {..}) instead.
  • All ScriptMethods now require a Fuse.Scripting.Context as the first argument.T
  • Added Node.findData(key) method which returns an observable of the data at key from the parent data context. Can be used to access inherited "global" data from pages/components.

Image async and WhileBusy

  • during loading images will now mark their nodes (and ancestors) as busy
  • use the WhileBusy to do something while loading
  • file image sources can also be loaded asynchronously now (previously it was only synchronous). Using MemoryPolicy="UnloadUnused" will use the asynchronous loading. The default setting of MemoryPolicy="PreloadRetain" will still use synchronous loading, though it isn't really "preloading" anymore.
  • SwipeNavigate now uses the parent of the gesture itself, not the navigation parent, to determine the swipe size. In most cases this shouldn't affect anything. If it does then place your SwipeNavigate inside the panel with the correct size, or set the LengthNode to the desired element.
  • Added PageControl.ActiveIndex and VisualNavigation.ActiveIndex. ActiveIndex is a two-way bindable property suitable for JavaScript to get and set the page, as well as respond to page changes.
  • A Router may now be used within a UX tree already containing a Router. This ends the path chain for the current router and allows distinct navigation for components.
  • Navigator gains the properties Reuse and Retain to control the lifetime of pages
  • NavigationControl.IsReusable is deprecated. Use Reuse and Retain instead


  • Add support for native LinearGradient in NativeViewHost on Android and iOS
  • Add support for native Ellipse shape inside NativeViewHost on Android and iOS

Native views

  • Fix issue where Android views would not rotate around the correct point
  • Fix issue where some native views would not forward input events to fuse on iOS
  • Fix issue where transforms on iOS could end up being incorrect
  • Fix issue where Circles with Strokes would not display correctly on Android
  • Add support for Opacity for elements inside <NativeViewHost />
  • Add support for ClipToBounds for elements inside <NativeViewHost />
  • Fix issue where <TextInput /> sometimes would not render correctly on older versions of iOS
  • Fix issue where setting Visibility to Collapsed or Hidden would not affect native views
  • Fix issue where Circles with Strokes would not display correctly on iOS

Data context improvements

  • Added support for multiple data objects per node. This fixes problems/ambiguities/bugs related to e.g. having multiple <JavaScript> tags per node, <JavaScript> directly on children of <Each>, <Select> etc.
  • As a result, Node.DataContext no longer exist, because there might be more than one data-contexts. For code where there were only one data-context, you can use Node.GetFirstData() as a replacement. Otherwise, you can use Node.GetLocalData to get all data-contexts, to figure out which one you need.

Triggers inside Each

  • Fixed data context bugs with triggers, Match/Case and StateGroup when used directly inside an Each tag.
  • Uno: WhileValue no longer implements IValue, but WhileTrue/False implements IToggleable, which means <Toggle /> still works on them.


  • The ScrollView.PropertyChanged event, and associated types, have been removed. Use the standard property changed system instead.
  • ScrollView public properties now generate property changed events


  • Several fixes were made to how Transform dynamically updates when using a RelativeTo and RelativeNode
  • The transform hierarchy has a new RelativeTransform layer from which some classes (Scaling, Translation) are now derived
  • The Transform.RelativeNode property is no longer available in other transform classes. It was not used in those anyway so it can be safely removed from your code.
  • The ITransformMode has changed to be more generic in how it handles subscriptions. If you're derived from this you'll need to implement the new interface and manually subscribe to events.
  • IResizeMode is no longer a ITransformMode. Resize subscribes to the Placed events of both the Target and RelativeNode


  • IViewport split into IViewport, IRenderViewport and common base ICommonViewport. This better tracks the intent of each viewport and identifies where they are being used. This was done since most locations that needed these could not provide the full interface previously, nor could they even define the fields correctly. If one of the fields you need is missing then please contact Fuse support to help with migration.
  • Viewport can now be used at an arbitrary location in the UX tree, not just as the root element
  • Viewport.Flatten has been removed, use Mode="RenderToTexture" instead.
  • Added IViewport.WorldToLocalRay
  • Visual.WindowToWorldRay has been removed, use Viewport.PointToWorldRay instead
  • Visual.WindowToLocal has been made non-virtual. As it can't reasonably be implemented by a derived class we assumed nobody has actually done this. Please contact Fuse support to help with migration if you did.
  • DefaultShading.Viewport is renamed to RenderViewport to avoid name collisions.
  • Trackball has a new default forward vector of 0,0,1 instead of 0,0,-1. This accounts for a normalization of our 3D space. This can be modified with the ForwardVector property.


  • Apps built in preview mode had before a postfix in the package/bundle name, so that a preview build and normal build could be differentiated, and live next to each other at the same time. Instead an optional project property replaces this feature. Called PreviewPackageName for Android, and PreviewBundleIdentifier for iOS. Eg.
    "Android": {
    "Package": "com.example.fuse",
    "PreviewPackage": "com.example.fuse.preview"
    "iOS": {
    "BundleIdentifier": "com.example.fuse",
    "PreviewBundleIdentifier": "com.example.fuse.preview"


  • Fuse.CacheFramebuffer is not longer exposed as a part of the public API. It was never meant as a visible part of the product. If you're using this, you'll have to implement similar functionality on your own.
  • Animating Text.Color and Stroke.Color does not generate a run-time warning anymore.
  • Effects: Fixed a bug where mask-textures didn't align properly with the element they were on, if the element itself was translucent but had non-translucent children.
  • StatusBar: Fix issue where setting a color on <Android.StatusBarConfig Color="#..." /> would not work
  • Fuse.Reactive: Fix an issue where the maximum call stack size was exceeded during the message-pump for Observables
  • Image: ResampleMode=Mipmap has been deprecated. This has effectively been the same as ResampleMode=Linear for a long time, and apps should use the latter instead. We now generate a warning if you use the former.
  • Fuse.Camera/Fuse.CameraRoll: Correct captured image orientation to EXIF values if available on Android. This solves camera orientation issues on Samsung devices.
  • Launcher: LaunchCall now works with telephone numbers containing spaces
  • GeoLocation: Fix spelling of property name auhtorizationRequest to authorizationRequest
  • Cycle: Add Cycle.FrequencyBack to control speed when returning to rest state
  • Text Rendering: Fixed a bug where text was being truncated/ellipsized on iOS when it shouldn't have been due to rounding errors.

Download this version

Fuse 0.23.0

  • Fixed a bug where fuse install android command would crash
  • <SolidColor Opacity="..." /> now works when used on Shapes and Panels inside a NativeViewHost
  • Fixed an issue where toggeling IsPassword would make TextInput on iOS change font and its caret glitch
  • Fixed an issue where IsPassword="true" would use the Android default monospace font. Meaning that Font="..." now works on Android password TextInputs
  • Fixed an issue where the background on iOS TextView would always be white
  • Added support for <Panel Background="..." /> and <Panel Color="..." /> on elements inside a NativeViewHost
  • Fixed an issue where Native views could “pop” for 1 frame as their transforms were not up to date
  • Match now inserts its nodes just after itself in the parent. This maintains the intended order. Previously is added to the end of the children – if you need to this then move the Match itself to the end of the children.
  • Fix an issue where changing the HitTestMode did not update the hit test bounds
  • Event-binding now correctly converts arguments, to prevent issues with invalid conversions when triggering events.
  • Fixed an issue on desktop where Caret would jump when an empty TextInput got typed into
  • Fixed an issue where databinding PlaceholderText to an observable could make iOS crash
  • Fixed an issue where errors during data-binding could result in an unhandled exception

Download this version

Fuse 0.22.0

Significant performance improvements in JavaScript data marshalling
  • Optimization: The JS/Uno interop layer has been rewritten to avoid thread sync when reading data from JS.
  • Optimization: The JavaScriptCore scripting implementation used on iOS has been rewritten to use the C interface instead of the Objective-C interface, which means that certain Uno-JS interoperations are much faster.
  • To allow important optimizations, exported JS data contexts containing reference loops are no longer supported and will generate a run-time error. This is unlikely to affect your app, but if it does and you are unable to migrate, please contact support and we’ll help you out!
Disk space savings
  • Preview will now reuse build directories when possible.
  • The Observable.slice() method has been added, providing similar functionality for observable lists as its JavaScript Array equivalent.
  • Observable.setValueExclusive replaced with Observable.setValueWithOrigin. See docs for details.
Native shapes
  • You can now render more shapes with the native renderer within NativeViewHost. Support for Shape, Rectangle and Circle has been added.
Running on iOS devices
  • When building with uno build --target=ios --run, the uno command now stays open, printing any output from the app to stdout. Building for Android and iOS now behave identically. (Previously, uno would exit as soon as the app was deployed to the iOS device.)
  • Camera.takePicture now throws an exception if passed negative width or height.
Renaming inside RaiseUserEvent
  • RaiseUserEvent.Name renamed EventName to match OnUserEvent and avoid the Node.Name conflict
  • The crashes in MapView during preview refresh should now hopefully be gone. A huge Thank You goes out to Uldis and the others who helped out with testing and debugging!
  • Blur and Desaturate both triggered an issue in iPhone 6’s OpenGL ES driver which caused transparent areas to become black. While others might have waited for driver fixes, we got someone clever to find an elegant workaround.
  • Data bindings now reset to the original value when the node is unrooted. Prevents flickering of old data during navigation in certain cases.
  • Multi-touch works on iOS again.
  • A bug where NativeViewHosts didn’t always have a NativeViewParent has been fixed.
  • A bug where WebView.Eval silently dropped pending evaluations has been fixed.
  • Fixed an issue with “object reference is null”, often seen while using the Router
  • Fixed a layout/hittest problem with the children of Viewport
  • Fixed an error that could occur from errors in the JavaScript thread during a refresh that could lead to the “Ooops!” screen being shown by mistake.
  • A warning about failed data-binding was removed, as it lead to spurious errors in valid use-cases.

Download this version

Fuse 0.21.0

  • Improved camera and gallery support
  • Support for ArrayBuffer in XMLHttpRequest
  • Stability improvements for MapView and WebView
  • Experimental support for Gradle in Android builds
  • Added support for sending and receiving ArrayBuffers in XMLHttpRequest. (req. responseType = 'arraybuffer')
  • Push & Local Notifications both now have clearAllNotifications and clearBadgeNumber methods
  • Added improved camera and image gallery JS APIs via the Fuse.Camera, Fuse.CameraRoll and Fuse.ImageTools packages
  • camera.takePicture({ targetWidth: width, targetHeight: height, correctOrientation: shouldCorrect }) is changed to camera.takePicture(width,height). To change orientation use imagetools.
  • Removed onTerminating from the js lifecycle api
  • Added state property where you can get the current state of the app
  • Also added the BACKGROUND, FOREGROUND & INTERACTIVE properties which are constant you can compare with the current state.
  • Added Fuse.Platform.Lifecycle and Fuse.Platform.InterApp for hooking onto application events in Uno.
  • Socket.Create has been replaced with the Socket constructor. Just do new Socket(...) instead of Socket.Create(...).
  • Socket.Poll now uses microseconds instead of milliseconds. Multiply old values with 1000 to get the same behavior.
Other fixes
  • MapView and WebView have been rewritten for improved stability and performance. Both views now support multiple concurrent instances as well.
  • Fixed visual glitch in iOS keyboard when moving focus between TextInputs
  • Fixed bug in where the caret in TextInputs on Android would be at the front of the string instead of the end of the string when focused
  • Implemented SelectionColor for TextInputs on Android
  • Fixed bug causing LinearGradient to not invalidate if any of its GradientStops are animated
  • PullToRelaod now creates default states for unspecified ones. If you previously didn't have a Rest state and were relying on Pulling being the default you'll have to set that to the Rest state now (it was a defect that another state accidentally became the first state).
  • Visual.InvalidateRenderBounds made protected since it's a call made only internal to the class
  • Added experimental support for building with Gradle on Android. Read more in the docs
  • iOS: Use the same default color forButton as XCode uses for UIButton

Download this version

Fuse 0.20.3

  • Notifications about new Fuse releases now work again on OS X
  • Fixed a bug where Text in TextInput did not show at init time on Android
  • Fixed a crash in Android MapView caused by polling properties on the MapView before it was fully initialized
  • Fixed a null reference in NativeViewHost that happend when unrooting and then rooting children on it

Download this version

Fuse 0.20.2

Welcome to Fuse 0.20!

This long-awaited release of Fuse comes with tons of shiny new features, improvements, bugfixes, optimizations and cleanups of old legacy to make Fuse truly ready for prime time. We have been working on this release behind the scenes for several months while releasing hotfixes to 0.12, and we are super excited to finally make it available.

All of this awesomeness comes at a price; this release has several backwards-incompatible changes. Please take your time to upgrade carefully. Depending on the size of your existing project, upgrading can take some time and may not be 1:1 with your old version.

If moving an existing project to 0.20, make sure you check out the Migration guide (also reproduced below).

We also have a new, greatly improved documentation system: http://www.fusetools.com/docs - go there for docs and examples on the features mentioned here.

New features & release highlights
New best practices for navigation, components & structuring your app
  • New classes Router & Navigator greatly simplify app navigation and structuring larger apps in a scalable way, while allowing full customization of transitions.

    • Easily navigate between pages of your app using router.goto(), .push() and .goBack() in JavaScript
    • Pass parameters to the route to "send messages" between pages
    • Multi-level navigation
    • Fuse preview remembers the route for each preview instance. No more being thrown back to the start page for every change
    • Back-buttons e.g in Android devices automatically work with Router.
    • Navigator takes automatic care of lazy-instantiating views, recycling inactive views, reusing views etc
  • New feature ux:Dependency allows dependency injection into ux:Class - improves ability to create reusable components in UX/JS.

  • JavaScript now has access to all objects in their scope by ux:Name and ux:Dependency through their scripting interface, e.g. ux:Name="foo" and then foo.doSomething() in JavaScript. This allows truly isolated components (ux:Class) with inner logic in JavaScript that works on the objects and dependencies of the class. The new documentation system now shows what methods are available from scripts on each class.
  • All ux:Property declarations are now implicitly available as Observables

Very high-level example of recommended app structure:

    <Router ux:Name="router" />
        router.goto("user", { id: 34 });
        <LoginPage ux:Template="login" router="router" />
        <HomePage ux:Template="home" router="router" />
        <SettingsPage ux:Template="settings" router="router" />
        <UserProfilePage ux:Template="user" router="router" />

where each of the pages is a ux:Class in a separate file, with <Router ux:Dependency="router" />.

See the documentation and examples for more in-depth information.

Fuse library cleanups & improvements
  • Each, Match/Case and triggers now preserve their intuitive ordering and can be nested without intermediary panels. Ooh yeah!
  • Styles, Themes and related features long considered deprecated are now eliminated. Long live ux:Class and reusable components!
  • Large refactoring of the core architecture for improved speed, reduced memory usage, eliminated memory leaks etc. If you have a lot of Uno code touching core things and run into issues, make sure you read the rest of the document carefully.
Fuse preview improvements
  • New Reset (Cmd/Ctrl+R) function in local preview.
  • Back button simulation (Cmd/Ctrl+B) in local preview. On iOS, hold 3 fingers for 1 seconds to bring up back button emulator.
  • Rotate device (previously Cmd/Ctrl+R) renamed to Flip device (Cmd/Ctrl+F)
  • You can now have both a fuse preview version and a fuse build version of your app installed on a phone at the same time (they now have different package identifiers)
More foreign code

Most of Fuse is now rewritten from the old native bindings system to the new foreign code system. What this means for you:

  • We will very soon open up an API to make it easy to write new UX wrappers for native controls yourself in foreign code. This means native control wrappers can be distributed as packages.
  • Once bindings are completely eliminated from the Fuse libraries, compilation times for Android and iOS will be reduced a lot. We're almost there now.
Migration guide (0.12 -> 0.20)
No more Themes or Styles
  • Remove the Theme property from your <App /> class. This means no more Theme="Basic".
  • Remove ux:InheritStyle, ux:Cascade, IgnoreStyle attributes, as they no longer have any meaning or effect.

An empty app now looks like this:


Note that all semantic controls (Button, Switch, Slider and TextInput) will no longer get the Basic theme apperance, but instead a much more plain generic look/no look at all. To keep the old appearance, prefix all uses of those controls with Basic., e.g. <Basic.Button />. Remember to add a reference to Fuse.BasicTheme in your .unoproj if you want access to this (not default).

The long deprecated <Style> tag is now finally removed. Rewrite to use ux:Class instead, which is a much nicer and much more performant way of doing consistent styling.

Some users have a legacy habit of using <Style ux:Class="MyStyle"> as a dummy-container for a collection of classes. In this case, you can simply replace <Style .. with <Panel .. or any other dummy to keep this pattern.

Changes in default package references
  • Remove all the Fuse.* packages (including FuseCore) and replace with two simple references to Fuse, FuseJS.

You might also want to add a reference to the following depending on whether you need a feature:

  • "Fuse.GeoLocation"
  • "Fuse.Camera"
  • "Fuse.Vibration"
  • "Fuse.Launcher"
  • "Fuse.PushNotifications"
  • "Fuse.LocalNotifications"
  • "Fuse.BasicTheme"

A minimal .unoproj file should now look something like this:

  "Packages": [
  "Includes": [

If you have references to Uno.* packages, whether you need to keep them around depends on whether you have .uno code depending on those packages.

If you want to use the Basic. controls, add a reference to Fuse.BasicTheme. These are now not included by default to avoid bloat in your generated app if you are not using it.

You need to keep references to third party packages that you depend on in either UX, Uno or JS.

ux:Global on JavaScript tags is now deprecated

Using ux:Global on JavaScript modules to make them accessible to require() will have unpredictable behavior in fuse preview.

Instead require the JS file directly by including it in your project as a bundle file, for example:

"Includes": [

and then use require with the filename instead:

var foo = require('foo'); // requires foo.js in the project root
var bar = require('./../bar'); // requires bar.js in the folder above the current file

Check out the detailed docs for more info.

Changes to TextInput and TextEdit APIs

TextEdit is now removed. TextInput now gives an undecorated text input control. If you want a decorated text input, you can get the old Basic style by using Basic.TextInput.

  • Replace all occurrences of TextEdit with TextInput. The previous use case for the TextEdit was to get an undecorated TextInput. Instead, the TextInput is now undecorated.
  • For existing TextInput, use the Basic.TextInput if you want to keep the old style, or keep as TextInput if you want to keep it undecorated. Y
  • TextInput is now always single line. To get the multiline version of TextInput, use a TextView instead.
  • PlainTextEdit no longer exists. Use TextInput instead.
  • As TextInput is invisible by default, you can use the new TextBox to get a decorated text input (easier while prototyping).

You can now style TextInput by putting elements inside it. It behaves like a DockPanel where remaining space is the actual editor:

    <Rectangle Dock="Bottom" Height="2" Color="Blue" Margin="4" />
Changes (bugfixes) to UX element ordering semantics
  • Elements placed inside Triggers will now be placed at the same location in the children list as their containing Trigger.

Here is an example where this matters:

    <Each Count="2">

The previous behavior turned the above UX into the following equivalent:


Notice that the element inside the Each are placed after element outside it.

The new behavior works like this:


The elements are now placed where you'd intuitively expect them to be.

Consolidated ux:Template and ux:Factory concepts

In UX markup, the concept of Factory has been renamed to Template. The old Template concept is removed (was used in Styles, which are now removed).

The new Template-concept is used heavily in the new Router/Navigator APIs.

  • Instead of ux:Generate="Factory" use ux:Generate="Template"

You can also create a named template by using ux:Template="the_name".

The PageControl.DotFactory has been renamed to PageControl.DotTemplate.

Changes to animation APIs
  • Attractor.SimulationType has been removed in favor of two new properties; Type and Unit. Take a look here for details.

  • LinearNavigation no longer has an Easing and Duration property.

If you need to use a custom Easing and Duration, rewrite

<LinearNavigation Easing="CubicOut" Duration="0.3" />

To this:

    <NavigationMotion Easing="CubicOut" Duration="0.3" />
Uno API Changes

These changes are only relevant if you have custom .uno code in your projects.

  • protected override void OnRooted() and OnUnrooted() no longer take the parent node as an argument. The Parent property is assumed to be set at the time these methods are called.

  • Nodes no longer have a separate list for elements, behaviors and properties. They are all in the same list called Children.

  • Many places that used to take in a Node now take in a Visual instead. For example, in theWhileLoaded trigger:

public static void SetState(Node n, bool loaded)

has become

public static void SetState(Visual v, bool loading)
UX/Uno changes in detail
  • The base type of navigation classes, Navigation, has been renamed to VisualNavigation (as it's navigation of Visual objects). The generic and static navigation functions, however, remain in the Navigation class.

  • PageControl now derives from a common base NavigationControl and some enums have been renamed: PageControlInactiveState => NavigationControlInactiveState, PageControlInteraction -> NavigationControlInteraction, PageControlTransition -> NavigationControlTransition.

  • Navigation no longer sends per-page progress messages, instead only updating the Navigation object itself. This should not affect UX-level user code, only Uno code that might have subscribed to these messages.

  • INavigation gains some new functions. PageProgressChanged is now a NavigationHandler.

  • PageControl.AllowedSwipeDirections and SwipeNavigate.AllowedDirections have been added to control the allowed swiping direction.

  • SwipeNavigate.SwipeDirection is replaced with SwipeNavigate.ForwardDirection to clarify the direction you swipe to go "forward". This new property is actually the opposite of the previous one, so if you have Left you want Right now, Up becomes Down, and vice-versa.

  • SnapTo, EndSeekArgs, UpdateSeekArgs and ISeekable have been made internal to Fuse.Navigation. These are implementation details that cannot be used publicly.

  • SwipeNavigation.SwipeAllow and PageControl.SwipeAllow to limit the direction the user may swipe. Default is Both, but may be Forward or Backward to allow swiping in one direction only.

UX Markup trigger-ordering now preserved (previously random/undefined)
  • The children of behaviors (e.g. Each, Match/Case WhileTrue) will now be added to their parent just after the trigger itself. This means the order of the UX file is now preserved even as triggers turn on/off. Previously the children would always be added to the end. If you need to add to the end, place the trigger at the end of the parent.
MapView changes
  • Removed ZoomMin and ZoomMax properties
  • Made iOS and Android maps respond to the same kind of zoom values (a factor between 2 and 21)
  • Fixed issue where databinding on MapMarker properties would fail outside of Each
TextInput changes
  • Added support for AutoCorrectHint to control auto-correct on iOS and Android
  • Added support for AutoCapitalizationHint to control auto-capitalization on iOS and Android
ScrollView sizing change

As styles are being deprecated, the manner in which the @ScrollView determines its content alignment and size has changed. It should, in most cases, be identical to before.

The one exception is with minimum sizing. If you previously did not specify an Alignment, Height/Width, or MinHeight/Width the minimum width would be set to 100% by default. This is no longer the case. If you need this then add MinHeight="100%" to the content of the @ScrollView.

Animation control for navigation and scrolling
  • Removed StructuredNavigation.EasingBack and DurationBack as they have no equivalent in the new motion system.
  • Deprecated StructuredNavigation.Easing and Duration as they are now ambiguous in the new system. In the interim they will be mapped to Motion.GotoEasing and Motion.GotoDuration, though the meaning is not exactly the same (use GotoDurationExp='0' on a NavigationMotion to get a flat duration as before). Refer to the full NavigationMotion type for details.

      <NavigationMotion GotoEasing="SinusoidalInOut" GotoDuration="0.4" GotoDurationExp="0"/>
  • Removed SwipeNavigation.SwipeEnds and PageControl.SwipeEnds; use a NavigationMotion with the Overflow property instead.

      <NavigationMotion Overflow="Clamp"/>
  • The package Experimental.Physics has been removed: the API is still under too much flux to release, and the code has been moved to a private package in Fuse.Motion (which exposes high-level interfaces where appropriate). If you were using some of this code in your project, please contact us and can make the previous source available.

  • Introducing the Fuse.Motion package for high level simulation and physics configuration/behavior
  • The option to set an Attractor.Simulation has been removed for now, as the simulations are private. Use the SimulationType parameter to configure the type.
  • Attractor.SimulationType has been removed. Use the Type and Unit property instead.
  • Deprecated ScrollableGoto in favour of ScrollTo. This is simply a name change -- the old name still works with a deprecation warning.
  • How triggers and animations work has been changed. This corrects a few defects and should be backwards compatible.

  • Padding on visuals/primitives is now applied differently to be more useful and consistent. The local visual does not honor the padding anymore, only the children.

    <Rectangle Color="#F00" Padding="5">
        <Rectangle Color="#00F"/>

Previously, the red rectangle would not be visible, since it was the same size as the child. Now, it will show in the padding area, since it ignores the padding for the local visual.

  • Change.MixOp has a new default of Offset rather than Weight. This changes how values are combined in a Change animator, fixing a few issues with easings such as BackInOut. For properties targeted by only a single animator the change is otherwise not noticable, only for 2+ animators. To get the old behavior use MixOp="Weight".
  • If you Change a Size property, such as Height, MinHeigth, Offset, etc. you must set the value of the property explicitly and not rely on the default setting. Animations from the default to a particular value will either not do want you want or do nothing at all.

  • TriggerAnimationState has been made internal (it already had an internal constructor) UpdateStage, Mixers and PostLayoutMixers have been removed. The Layout stage is no longer exclusive layout, and includes all trigger updates. The AddDeferredAction function takes a priority to assist in sub-stage ordering. Triggers should more universally use bypass mode during rooting. If you notice an animation that isn't playing when you desire, then use the Bypass="Never" mode, or ask for assistance on how to configure the effect you want.

  • ux:Generate="Factory" is replaced with ux:Generate="Template" to be consistent with the new ux:Template feature.

  • Element.CalcRenderBounds no longer includes the ActualSize of the element by default. If there is a background it will, otherwise the derived classes must provide their correct size (in addition to calling the base implementation).

  • Fuse.Controls.Number has been deprecated. Use a Text control instead with JavaScript formatting:

    exports.DisplayValue = this.Value.map(function(x) { return "$ " + x; });
  • OnUserEvent.Name is renamed to OnUserEvent.EventName. This is to avoid a conflict with the generic Node.Name that arises due to the Node/Trigger refactoring.

  • KeyframeInterpolation.CatmullRom has been given the friendlier name Smooth. The old name is left an alias for now (it will be removed at some point).

Uno / Foreign code improvements
  • Fixed a bug which resulted in comments not working in foreign Objective-C.

  • Added support for writing constructors using foreign code.

  • Foreign Objective-C code is now automatically wrapped in an Objective-C @autoreleasepool.

  • Support for transitive project references.

    Given the projects App, A & B:

    • App refences A, which has a transitive reference to B.
    • This means that App has a implicit reference to B through A.

      You can use transitive references in your project file like this:

      "IsTransitive": true

      This will make all references in your project transitive, effectively making your project a transitive package.

  • New default package names (Android) and bundle identifiers (iOS)

    • By default we use the string com.apps.@(Project.Name) converted to lower case.
    • This was done to solve collisions in the file system causing builds to fail.
    • On iOS, _ is replaced by - because _ are not allowed in bundle identifiers.

      If you want to override the defaults, you can edit your .unoproj.

      "Android.Package": "com.domain.my_app"
      "iOS.BundleIdentifier": "com.domain.my-app"

      Users that have apps in app stores probably want something that fits their app or organization, rather than the defaults.

  • New add no-build command.

    This allows deferring --build, --debug & --run without triggering a full uno build. Options are simplified but similar to uno build, please see uno no-build --help.

    One example:

      cd <project-dir>
      uno build ios --no-native
      uno no-build ios --build --run

    Thanks to @bolav for suggesting this feature.

  • C++/MSVC: Added *.natvis files for Visual Studio. This makes debugger better able to visualize Uno objects.

Download this version

Fuse 0.12.4

  • Added support for AutoCorrectHint to control auto-correct on iOS and Android
  • Added support for AutoCapitalizationHint to control auto-capitalization on iOS and Android
  • If iOS was the first target you built for after installing Fuse, you could get 'uBase/config.h' file not found in XCode
  • Some users on Windows 10 would get /Android/android-sdk\extras\android\support\v4\android-support-v4.jar"" was unexpected at this time. when building for Android
  • In preview, if a TextInput was set to have IsPassword="true", it was not possible to change it back to false

Download this version

Fuse 0.12.3


This release fixes the following issues:

  • Fixed an erratic crash while performing HTTP-requests in MSVC and CMake targets.
  • Fixed a bug where an app launched with URI scheme doesnt fire the ReceivedURI handler
  • Fixed a bug on Android where LaunchUri crashed when an activity was not found to handle the request.

In addition, the following was fixed in 0.12, but was missing from the change log:

Foreign Code
  • Fixed a bug which resulted in comments not working in foreign Objective-C.
  • Added support for writing constructors using foreign code.
  • Foreign Objective-C code is now automatically wrapped in an Objective-C @autoreleasepool.

Download this version

Fuse 0.12.2


This hotfix release fixes the following issues:

  • Certain projects using UX templates would get stuck in Preview at "Host is loading project.." This mostly affected some users using the <Style>-tag
  • Added a workaround for a bug in the iPhone 6 GPU driver that lead to masks being rendered incorrectly
  • Fixed a memory leak when loading images
  • Updated the Android SDK installer to work with the new license acceptance procedure from Google

Download this version

Fuse 0.12.1


This is a hotfix release that fixes two bugs:

  • fuse install android would fail to install Ant.
  • When using multiple data contexts in a hierarchy (e.g <JavaScript> tags), inner scopes would not be notified of changes to the outer scopes, effectively losing data bindings for these cases.

If you already have Android support installed on your system, and are not using multiple data contexts in a hierarchy, you can safely skip this version.

Download this version

Fuse 0.12.0


  • After upgrading, please run fuse install android to update/fix required components for Android deployment
  • Added verbose output mode for fuse preview command, which can be switched on by using '-v' or '--verbose' flag


  • Fixed bug which could lead to crashes when previewing on Android
  • Fixed bug causing preview to be stuck on "Host loading project..."
  • Fixed memory leak in .NET export on Windows
  • Fixed bug causing preview to be very slow when using the <Video>-tag

Sketch importer (experimental)

  • Support for Sketch 3.7. Note that some documents created with older versions of Sketch might have problems. To fix this, simply open them in Sketch 3.7 and re-save
  • Default units is now percentages instead of points, for better handling of responsive layouts
  • TextColor is now set to trimmed HEX color values instead of RGBA
  • TextAlignment is now being respected in multi-line text boxes
  • Relative paths to .sketch-files are now supported
  • In previous versions, the importer output would sometimes be written to the source .sketch file folder instead of the folder the command was run from. This no longer happens.
  • Some smaller bugs and inconveniences are dealt with (some of which were too embarrasing to mention)


  • Add Uno.Permissions. Currently this is android only but will be expanded to iOS in due course. It supports both the old Android static permissions and the newer request-based permissions
  • All Uno projects now include the android 'support-v4' library. This means there is no longer a dedicated uno package for 'support-v4'


  • Now supported on both iOS and Android

Bug fixes

  • Fixed a compilation error ("Cannot create weak reference") that surfaced after updating to Xcode 7.3

Resolution and density changes

  • PointDensity => PixelsPerPoint
  • OSPointDensity is deprecated, replaced with a PixelsPerOSPoint which is not the same actual value


  • ScrollingAnimation.ScrollDirections by default now matches the ScrollView.AllowedScrollDirections (instead of just being vertical). If Both are allowed then Vertical is used. You can still override as desired.
  • BringIntoView and collapsing items should now be properly reflected in the scroll position
  • Added ScrollingAnimationRange.SnapMax, similar to SnapMin except for the maximum end of the ScrollView snapping area
  • ScrollView respects SnapToPixels better now (there were a few cases previously where it would not)

CIL backend change in behaviour:

Previously the CIL backend would skip compiling a class, and link an existing one, if an existing class exists. Now the CIL backend will only attempt to link classes marked with [DotNetType]. If you get a problem, you should add [DotNetType] on your class.

Download this version

Fuse 0.11.1

This hotfix release fixes an issue where some projects would be stuck at "Host is loading project" in preview.

Download this version

Fuse 0.11.0

Hotfix (build 6183, rolled out Sat Mar 26th)

  • Fixes problem with Xcode 7.3 compatibility causing problems with iOS builds and preview.

Bug fixes

  • The error manifesting as Daemon handshake failed: Request failed: (6) - Daemon key was not right has been fixed.
  • Fixed a regression in last release, where preview of a project, which was located on an external device (eg. USB stick) would fail.
  • ColumnLayout now handles Max/Min layout constraints correctly. If you notice a change in your layout look to the MaxWidth/Height property to verify that if it is what you want.
  • Fixed bug where Video would crash on certain devices (ex LG G2)
  • Fixed issue where GeoLocation.StartListening ignored the parameters

Known bugs in this release

  • On some devices, rotating the device will corrupt the UI
  • Tapping generic map markers in iOS MapView do not display text labels.
  • Tapping user location marker in iOS MapView is broken.
  • Using Change with pixel (px) units does not currently work.

UX Updates

  • Change now supports units (%, pt). The original and target value must have the same units.
  • this is now the implicit name of the current ux:Class or ux:InnerClass root node, so you don't have to explicity name the node to work with its contents.
  • PageControl.HitTestMode is now LocalBoundsAndChildren by default so that items without a background can be swiped. If there is some reason you don't want this just override HitTestMode="LocalVisualAndChildren" on the Pagecontrol to get the previous behaviour.
  • The ZOffset property has been introduced to control z-ordering of nodes
  • A new RangeAdapter that allows finer control over playback of parts of animations
  • MapView: The MapMarker Location property has been removed. Use Latitude and Longitude properties instead.
  • TextInputHint.Number has been renamed to the more accurate TextInputHint.Integer. Number is still available as a deprecated alias during the transitional period to be removed in a future release.
  • TextInputHint.Decimal has been introduced to allow decimal point value input.

JavaScript updates

  • State transition with StateGroup and State can now be done in JavaScript
  • Animation playback of a Timeline can now be controlled in JavaScript
  • Limited scrolling in a ScrollView is available now in JavaScript
  • MapView tilt, bearing, location, zoom and markers can now be controlled in JavaScript.
  • WebView url and loading of html can now be controlled via JavaScript goto(myUrl) and loadHtml(myUrl, myBaseUrl)
  • Added an Observable.toArray method that returns a copy of the values array
  • Deleted obsolete modules: FuseJS/Fetch and FuseJS/FetchJSON. Use plain fetch() instead.
Improved require() function (FuseJS)

require() can now require script files directly from the bundle, without declaring them as ux:Global. (If you want all .js files in the project folder to be bundled then simply add "*.js:Bundle" to the Includes in your .unoproj. And keep in mind that all changes to the .unoproj itself requires a recompile.)

You can now require files relative to the current script, or relative to the project root like this:

var foo = require("./foo"); // relative to this file
var bar = require("/bar.js");  // relative to project root (.js is optional)
var bar = require("bar");  // relative to project root, or global module

The bundle is also properly simulated in fuse preview, so adding new script files can be done on the fly. Oh, and it now also deals with circular dependencies gracefully. Happy birthday!

Foreign Code

  • Added support for out and ref parameters in foreign Objective-C functions.
  • Added a new ForeignInclude attribute which can be used to add imports in Foreign Java and to add headers in Objective-C.
  • Added support for using interfaces as parameters to foreign Objective-C functions.

See the handbook for more information about these features.

Uno updates

  • Fuse.Scripting.Marshal is available to convert from JS types for Uno callbacks
Changes to Fuse.Node
  • The Node.Update event is removed (legacy API). Instead add and remove actions directly to UpdateManager when the object in question is rooted.
  • The Node.Added and Node.Removed events are removed (legacy API). Add/remove operations have no logical consequence, and nothing should ever need to happen in response. instead, care about Rooted/Unrooted semantics.
  • The Node.OnAdded/OnRemoved has been removed, and hence rooting protocol has changed. If you relied on these methods, contact the Fuse crew on the Slack community for help to migrate.
Changed how properties with units (%, px, pt) are implemented

Removed StylePropertyWithUnit, instead introduced Unit, Size and Size2 in the Uno.UX namespace.

All properties that support units (such as Width, Height, Anchor) are now of type Size or Size2, and can be set in Uno code like this:

elm.Height = 100; // defaults to points, implicit cast from float and int to Size
elm.Height = Size.Points(100); // does the same as the line above
elm.Width = Size.Percent(30);
elm.Anchor = Size2.Percent(50, 50); // sets Anchor="50%,50%"
elm.Offset = new Size2(Size.Points(100), Size.Pixels(30)) // sets Offset="100,30px"

Download this version

Fuse 0.11.0

Bug fixes

  • The error manifesting as Daemon handshake failed: Request failed: (6) - Daemon key was not right has been fixed.
  • Fixed a regression in last release, where preview of a project, which was located on an external device (eg. USB stick) would fail.
  • ColumnLayout now handles Max/Min layout constraints correctly. If you notice a change in your layout look to the MaxWidth/Height property to verify that if it is what you want.
  • Fixed bug where Video would crash on certain devices (ex LG G2)
  • Fixed issue where GeoLocation.StartListening ignored the parameters

Known bugs in this release

  • On some devices, rotating the device will corrupt the UI
  • Tapping generic map markers in iOS MapView do not display text labels.
  • Tapping user location marker in iOS MapView doesn't work yet.

UX Markup Improvements

  • Change now supports units (%, pt, px). If no unit is provided, it is assumed to be the same unit as the target value (backwards compatible).
  • this is now the implicit name of the current ux:Class or ux:InnerClass root node, so you don't have to explicity name the node to work with its contents.
  • PageControl.HitTestMode is now LocalBoundsAndChildren by default so that items without a background can be swiped. If there is some reason you don't want this just override HitTestMode="LocalVisualAndChildren" on the Pagecontrol to get the previous behaviour.
  • The ZOffset property has been introduced to control z-ordering of nodes
  • A new RangeAdapter that allows finer control over playback of parts of animations
  • MapView: The MapMarker Location property has been removed. Use Latitude and Longitude properties instead.
  • TextInputHint.Number has been renamed to the more accurate TextInputHint.Integer. Number is still available as a deprecated alias during the transitional period to be removed in a future release.
  • TextInputHint.Decimal has been introduced to allow decimal point value input.

JavaScript updates

  • Added an Observable.toArray method that returns a copy of the values array
  • Deleted obsolete modules: FuseJS/Fetch and FuseJS/FetchJSON. Use plain fetch() instead.
Improved require() function (FuseJS)

require() can now require script files directly from the bundle, without declaring them as ux:Global. (If you want all .js files in the project folder to be bundled then simply add "*.js:Bundle" to the Includes in your .unoproj. And keep in mind that all changes to the .unoproj itself requires a recompile.)

You can now require files relative to the current script, or relative to the project root like this:

var foo = require("./foo"); // relative to this file
var bar = require("/bar.js");  // relative to project root (.js is optional)
var bar = require("bar");  // relative to project root, or global module

The bundle is also properly simulated in fuse preview, so adding new script files can be done on the fly. Oh, and it now also deals with circular dependencies gracefully.

Foreign Code

  • Added support for out and ref parameters in foreign Objective-C functions.
  • Added a new ForeignInclude attribute which can be used to add imports in Foreign Java and to add headers in Objective-C.
  • Added support for using interfaces as parameters to foreign Objective-C functions.

See the handbook for more information about these features.

Uno updates

  • Fuse.Scripting.Marshal is available to convert from JS types for Uno callbacks
Changes to Fuse.Node
  • The Node.Update event is removed (legacy API). Instead add and remove actions directly to UpdateManager when the object in question is rooted.
  • The Node.Added and Node.Removed events are removed (legacy API). Add/remove operations have no logical consequence, and nothing should ever need to happen in response. instead, care about Rooted/Unrooted semantics.
  • The Node.OnAdded/OnRemoved has been removed, and hence rooting protocol has changed. If you relied on these methods, contact the Fuse crew on the Slack community for help to migrate.
Changed how properties with units (%, px, pt) are implemented

Removed StylePropertyWithUnit, instead introduced Unit, Size and Size2 in the Uno.UX namespace.

All properties that support units (such as Width, Height, Anchor) are now of type Size or Size2, and can be set in Uno code like this:

elm.Height = 100; // defaults to points, implicit cast from float and int to Size
elm.Height = Size.Points(100); // does the same as the line above
elm.Width = Size.Percent(30);
elm.Anchor = Size2.Percent(50, 50); // sets Anchor="50%,50%"
elm.Offset = new Size2(Size.Points(100), Size.Pixels(30)) // sets Offset="100,30px"

Download this version

Fuse 0.10.0

  • Experimental MapView for Android and iOS.
  • Synchronization between UI and JavaScript has been rewritten. Glitches be gone!
  • You can now read bundled files directly from JavaScript.
  • A bunch of very nice Foreign code updates
  • ux:InnerClass introduced to make it even easier to split up code with ux:Include
  • PageControl has received some touch-ups to make it more flexible

And much much more! Read on for details...

Various bug fixes
  • We fixed a race condition that could cause random failures when starting preview on some systems
  • If you've had issues with preview processes hanging on exit, this release is for you
  • Fixed issue where WebView Url could only be set via observable strings (!)
  • Fixed bug in FuseJS Observable implementation that caused some subscribers to receive outdated update messages.
  • Fixed bug in observable propagation that would sometimes give wrong array data in the UI.
  • Resolved an issue with previewing projects located on other file system volumes than where Fuse was installed
  • Binding UX events to Uno methods is now supported in preview (Note that partial classes of ux-files in the project are still ignored by preview. If you don't know what partial classes are then you're doing it right!)
  • You now get the Window.Closed event in preview even on Windows
  • Fixed an issue with the selection cue not redrawing when it should
  • Naming your project file only ".unoproj" now works with the dashboard. (You asked for it!)
Known bugs in this release
  • On some devices, rotating the device will corrupt the UI
  • Animation may be slow on some devices
  • Tapping generic map markers in iOS MapView do not display text labels.
  • Tapping user location marker in iOS MapView is broken.
  • Zoom value on iOS MapView isn't correctly set on first load.
Introducing Experimental MapView for Android and iOS

This release introduces the new cross platform control Fuse.Controls.MapView in the Fuse.Maps package. See the handbook for more information. This is still fresh out of the oven so let us know if you run into any issues!

Foreign code

The team has been chipping away at that "coming soon"-list and for several features it turns out that "soon" has become "now"!

  • Added support for processed foreign Objective-C files
  • Added support for passing delegates to and from foreign Objective-C functions
  • Added support for passing arrays to foreign Objective-C functions
  • Added support for passing arrays to foreign Java functions
  • Added support for passing delegates to foreign Java functions

See the handbook for more details about these features.

Improved support for bundle files

Files included in your project file with the :Bundle suffix can now be read directly from JavaScript. This is done using either the read() or readSync() methods in the new module fuseJS/Bundle.

In Uno, the old Uno.BundleFile API has been replaced by the new Uno.IO.Bundle and Uno.IO.BundleFile APIs. The new APIs supports useful stuff such as listing the bundled files and observing them for changes (in the case of preview).

Improved UI/JS synchronization

In Fuse, JavaScript and UI runs on separate threads so that JS workload will never affect the smoothness of the native UI animation. However, up until this version, there has been some problems with update latency and inconsistencies due to the UI updating piecewise, giving weird "glitch frames".

This should now be fixed. We rewrote the synchronization between UI and JavaScript to make it faster, prettier and always consistent. As it should be.

Changes and improvements to PageControl
  • Page is no longer a special case for animation. Every child is equal in the eyes of PageControl!
  • You can now have nested pagecontrols.
  • New PageControl.InactiveState to control the visibility/enabled status of inactive pages. By default they will now be collapse and disabled for efficiency reasons. To get the old visible/enabled behaviour set InactiveState="Unchanged"
  • New PageControl.Transition and PageControl.Interaction to control default navigation behavior. See the PageControl docs for details.
NativeWithFallback theme has been moved

The NativeWithFallback theme is now only available if you include the Fuse.BasicTheme package (it's what implements the fallback).

Introducing AlternateRoot

AlternateRoot was added to allow adding nodes to a parent other than where they currently are in the UX tree

ux:Global support for value types

You can now create ux:Global objects of value types, such as float4. This is convenient e.g. for creating global color constants.


Added support for ux:InnerClass, which is a class that has access to named UX objects in its scope. Specifically, the differences are:


    Declares a global class that can be used anywhere.
    Such classes have no access to ux:Names the scope in which they are declared.


    Declares a class that can only be used in the scope where it is declared.
    In return, it has full access to all ux:Names in the scope it is declared.

    Inner classes can be extracted into separate .ux files, and then included
    using <ux:Include File="Foo.ux"> in the scope you want to use it.

    Inner classes can not specify namespaces, they will implicitly be in the
    name scope of their containing class.

    If root nodes are marked ux:InnerClass, they are ignored by the UX compiler
    unless ux:Included somewhere.
ux:Name must be unique per scope

It is an error to have two elements with the same ux:Name within the same scope.

  • Primitives, Image, Shape, and TextControl, should not have any child nodes. This is being deprecated and the ability will be removed. It can only be partially enforced at the UX level (unfortunately with a not-so-clean error message for now). These nodes need to be leaf nodes for optimization reasons.

    A common previous scenario might have been to add a Rectangle to a Text node:

      <Text Alignment="Center" Padding="5">
          <Rectangle Layer="Background" Color="0,1,1,1"/>

    This should now be done using a wrapping Panel instead:

      <Panel Alignment="Center">
          <Text Alignment="Center" Padding="5"/>
          <Rectangle Layer="Background" Color="0,1,1,1"/>
  • Shapes (Circle, Ellipse, Rectangle, Star, RegularPolygon, Path) are no longer implemented with visual children in Graphics mode. They are directly drawn in the semantic control type. This will not likely affect any user code.

  • Padding has been fixed in some shapes. This may change the positioning of shapes that have padding.
  • Node.InvalidateVisual is no longer virtual, override the OnInvalidateVisual function instead. This gives Node better control over when it is called, and how to invalidate
  • Node.IsVisualInvalid has been removed as the invalidation system is active (at time of invalidation), thus nothing should (or did) check that flag
Uno C++ changes

Changes in base libraries (uno-base)

- `Xli/Foo.h` -> `uBase/Foo.h`
- `Xli::Foo` -> `uBase::Foo`
- ...

Ask us on the community slack in the #uno channel if you run into any problems.

UXL changes

Required Xcode.Frameworks that have file extensions now do not get an additional .framework extension.

Download this version

Fuse 0.9.11

This release fixes the following bugs in 0.9.10:

  • Fixed a bug where JavaScript tags in the root of the document would not properly update in preview (causing fixed JavaScript errors to show up over again)
  • A reference to Fuse.Scripting was missing from the default project templates
  • Fixed a bug if NDK and Ant was located in a path with parentheses on Windows, which caused build errors during Android export.

Download this version

Fuse 0.9.10

  • A number of fonts were removed from the BasicTheme to avoid bloat. If your project depends on any of these you can explicitly add them.
  • New Color properties makes things more consistent (yeay!) and makes it a lot simpler to animate colors (double-yeay!)
    • Fuse.Controls.GraphicsView.Background has been removed entirely in favor of simply using Control.Color
  • Several updates and additions relating to animation, interaction and layout. The most notable ones are:
    • Changes in how you use Pulse and TimeLine
    • New gestures (none of them rude!)
  • Several bug fixes, such as the ability to have folder names starting with "u".
New Color Properties

All controls (panels, shapes, text etc.) as well as Stroke now have a general purpose Color property, which is of type float4. This property controls the main color of the object. For a Panel it corresponds to Background. For a Shape, it corresponds to Fill, etc.

The main benefit of this property (beyond just being a nicer and more consistent name), is that Color as it is a float4 can be animated using <Change something.Color=.., while Background, Fill and Brush cannot (as they are brushes).

We reccommending changing all uses of Background and Fill to Color when you only want to assign a static color. All examples and docs are updated to reflect this.

Removed fonts from Fuse.BasicTheme

A number of Roboto fonts were removed to avoid unnecessary bloat. In order to use them in your projects you can simply add them as globals yourself, as described here.

Various updates to layout, animation and gestures
  • New ColumnLayout.ColumnSize that allows a dynamic ColumnCount based on the availabe size
  • Attractor now better works with 2-way bindable values (something else can modify the target value that is also used in an attractor)
  • Added RelativeTo="Size" to Resize allowing resizing to the size of another element
  • Added ZoomGesture, RotateGesture, PanGesture and InteractiveTransform
  • All interactions can now be cancelled, the CancelGestures action can be used to do this.
  • A Cancelled argument is added to Node.BeginInteraction. Behaviours must support this is they support interaction.
  • Timeline is now off by default at progress 0, use OnAtZero="true" to force it to be on at progress=0. This setting is actually uncommon, and should only be used if you're certain it is applicable (when the animators don't have a rest state)
  • Pulse should no longer be used on a WhileValue /WhileTrue trigger and will trigger deprecation warnings. Use a Timeline instead if you need Pulse funtionality
  • New PulseForward that plays a Timeline to the end and then deactivates it
  • New PulseBackward that plays a Timeline to from the end to the start
Bug fixes in FuseJS
  • Fixed a bug where certain UX filenames (e.g. folders starting with 'u' on Windows) caused exceptions in JavaScript elements due to unescaped paths.
  • UTF-8 in JavaScript on Windows DotNet builds should now work.
Bug fix in Uno C++ backend
  • Fixed a bug where the finally block in a try-finally statement was not run if the try block returned.

Download this version

Fuse 0.9.9

Just to avoid any false expectations: The fact that this is release 0.9.9 does not mean the next release will be 1.0! :)

  • Fuse.Controls.GraphicsView.Background has been renamed to Fuse.Controls.GraphicsView.BackgroundColor to better reflect that it's a color, and prevent shadowing Fuse.Controls.Control.Background
Circular layout and behaviour
  • Fuse.Controls.Graphics.LinearSliderBehavior renamed to Fuse.Gestures.LinearRangeBehavior to make it more accessible.
  • the Node.PointDensity shortcut to Viewport.PointDensity has been removed as it caused an unresolvable loop in the code. Just use Viewport.PointDensity as there should always be a viewport on rooted nodes.
  • CircleLayout can be used to arrange children around a circle, or partial circle
  • RangeControl2D is a 2d semantic range control (there is no standard visual implementation of this)
  • CircularRangeBehavior can be used for range controls to create a circular, or arc, based control
  • Element.IsInteracting moved to Node.IsInteracting to support general interactions on nodes
  • InteractionCompleted indicates the user is done interacting with an element (counterpart to WhileInteracting)

  • ElasticForce.CreateRadians renamed CreateAngle, CreateDegrees removed and the adapters AngularAdapter and AdapterMultiplier added. Avoid using these directly though, use only DestinationSimulatorFactor.Create.

  • DestinationSimulationType.ElasticForceRadians changed to DestinationSimulationType.ElasticForceAngle This is to change the type into a flags type and be more generic.
Uno language
  • Added @(Macro) and @keyword

      string projectName = @(Project.Name);
      string @enum = "this strings name is a keyword";

    @(Macro) expressions allows you to access settings from your Uno project, UXL or the command-line. The return value is always string.

    Uno supports built-in macros which will return different values based on context.

    Built-in macro Returns
    @(FILE) Path to the current source file.
    @(LINE) Number of the current line.
    @(DIRNAME) Path to the parent directory of @(FILE).
    @(PACKAGE) Name of the package containing @(FILE).
    @(PACKAGE_DIR) Root directory of @(PACKAGE).
    @(PACKAGE_VERSION) Version of @(PACKAGE).
  • Added [Attribute] on enum literals

      enum Foo
          Baz = 1
  • A bug was introduced in 0.9.8 where Fuse would ignore Android icons set in .unoprojs. This has been fixed.
  • A problem where Android NDK could not be used from a path with spaces has been fixed.
  • Fixed a regression introduced in 0.9.8 where a new build folder was used for each preview instance, when exporting to Android or iOS. The effect caused preview build to use a lot more time.

Download this version

Fuse 0.9.8


  • Build output directory changed from .build to build (see "New project build directory defaults")
  • Introducing foreign code blocks in Uno
  • Introducing ux:Include
  • Improved ux:Property support
  • V8 JavaScript engine is now used in local preview and all local builds
  • Lots of fixes and improvements to triggers and animators (See for instance WhileInteracting and Timeline)
  • Lots of new project properties for iOS
  • New APK launcher with improved error messages, and that prints relevant logcat from device
  • Fixed case where android platform 19 was not installed (which resulted in platform target 19 not found error)
  • Fixed several bugs related to spaces in paths or names
Introducing foreign code blocks

Uno methods marked with the [Foreign(Language.LANGAGE)] attribute, where LANGUAGE is ObjC or Java, can contain code written in the foreign language by specifying the body inside alpha braces, @{ ...@}, e.g.:

void Foo()
    System.out.println("Hello, World");

Foreign functions automatically convert the arguments and return value from their Uno representation to a corresponding foreign language representation. Primitive types (int, char, float, etc) are converted to the corresponding primitive type in the foreign language. Other types are automatically converted in both directions according to the following tables:

Uno Java
string String
Java.Object Object
object UnoObject
Uno Objective-C
string NSString*
ObjC.Object id
object id<UnoObject>

UXL macros such as Call (@{Type:Of(thing).Method(argTypes):Call(args)}), Set, and Get can be used to call back to Uno code from the foreign code block with reversed type conversions.

If the foreign method is an instance method, the foreign code block can additionally access the wrapped this object in the automatically added _this parameter.

To avoid having to use extension files at all in the common case, you can now specify [Require("Key", "Value")] as attributes on Uno classes and methods in place of specifying <Require Key="Value" /> in a separate extensions file.

The uObjC.Reference.h header, used by some for low-level Objective-C interop, has been renamed to uObjC.UnoObject.h. The classes in it have also been renamed: Uno_Reference is now UnoObject and Uno_{Strong,Weak,Unsafe}Reference are now {Strong,Weak,Unsafe}UnoObject.

Changes to project format

In relation to foreign code blocks, some additions has been made to the .unoproj file format.

Native source files can now be included using the file types CSource, CHeader, and Java. This replaces using the file type File and specifying <ProcessFile {Header,Source}File="filename" /> in an extensions file.

An include condition can be speficied to avoid including files on platforms where they are not supported:

"Includes": [

Useful pre-defined values for CONDITION include Android and iOS.

Improved extern code

Even before the introduction of foreign code, interop with native C/C++ libraries from Uno could be done using the extern keyword. This release improves upon that feature by introducing extern blocks:

int arg = 10;
extern (arg)
    printf("%d", $ 0);

When only access to method arguments is needed, the extern header can be omitted

void foo(int arg)
    printf("%d", $ 0);
Introducing ux:Include

The new UX syntax <ux:Include File="Foo.ux" /> will insert the contents of another UX file at the given location. This makes it easier to split large UX components into separate files.

Breaking change! UX markup files with no ux:Class on the root node no longer produce a class based on the file name. You have to explicitly set a class name on the file's root node (ux:Class="ClassName"). The UX compiler will politely tell you how to fix this in a compile-time error message.

Improved ux:Property support

Several bugs related to ux:Property has been fixed, both in preview and when running exported.

In addition, nodes marked with ux:Property no longer represents the default value, but just a definition of the property. You can still specify a default value the same way you set other properties in a ux:Class definition, e.g.:

<Panel ux:Class="MyPanel" ux:Name="self" Paint="#f00">
    <Brush ux:Property="Paint"/>
    <Rectangle Fill="{Property self.Paint}"/>

<MyPanel Paint="#00f" />

You can also use ux:Binding to set a complex object as default value:

<Panel ux:Class="MyPanel" ux:Name="self" >
    <Brush ux:Property="Paint"/>

    <LinearGradient ux:Binding="Paint">
        <GradientStop Offset="0" Color="#f00" />
        <GradientStop Offset="1" Color="#0f0" />

    <Rectangle Fill="{Property self.Paint}"/>

Note that for {Property self.Paint} to work, the declared property type has to exactly match the type where it is used (Brush).

V8 all the things!

We now use V8 as JavaScript engine on both OS X and Windows for local preview builds, DotNet builds, CMake builds, and MSVC builds. The V8 library has also been updated to version

One of the benefits of using V8 is the debugger, which can be enabled using the -DDEBUG_V8 build flag. See the debugging guide for more information on how to use it.

New default build directories

All builds are now placed within the "build/" subfolder of your project by default, instead of ".build/" for builds and ".preview/" for preview. Remember to update your .gitignores!

The reason for this is that the old build directory starting with a . gets hidden by default in OS X, causing some confusion. E.g. when you want to open the build output in another program that doesn't support showing hidden files, the non-dotted directory is now much easier to find.

If this cause trouble, you can pass --out-dir to uno build to override, or configure your project using these old settings:

"BuildDirectory": ".build",
"CacheDirectory": ".cache",
"OutputDirectory": "$(BuildDirectory)/@(Target)-@(Configuration)"

This will, however, not have an effect on fuse preview.

Changes to Timeline element
  • Timeline will now use a backwards animation when playing backwards
  • TriggerAnimation.CrossFadeDuration (via Trigger.CrossFadeDuration) allows changin the duration of the cross-fade between forward/backward animations on direction switches
  • Timeline is now "active" at Progress=0. This allows animators to have an effect even at this progress -- on other triggers the animators are essentially removed when the Progress==0.
  • Timeline.PlayMode added with the option of Wrap to loop the timeline
  • Progress at rooting time can now be set using the Timeline.InitialProgress property
  • Timeline.Progress is now a two-way bindable value
  • Pulse.Target is now an IPulseTrigger allowing more items to be pulsed, such as Timeline
Changes to Cycle element
  • The properties Cycle.IsZeroCrossing and Cycle.IsOneCrossing have been made internal (they were not meant to be public)
  • The new property Cycle.ProgressOffset allows specifying the offset instead of taking the auto-calculated one. This may result in jerky animations on starting/stopping a trigger.
  • The new property Cycle.Easing allows an easing funtion to be applied to the progress. This disables the auto-calculated ProgressOffset and may reuslt in jerky starting/stopping.
Other API changes and improvements
  • A new trigger called WhileInteracting has been added. This trigger is active while the user is swiping in a SwipeGesture or scrolling in a ScrollView.
  • IsInteracting has been moved up from Control to Element
  • Swipe.IsActiveChanged is now of type ValueChangedHandler<bool>. SetValue renamed to SetIsActive. 2-way data binding enabled.
  • The swipe length of a SwipeNavigate element can now be taken from another element using the new LengthNode property
  • SwipeNavigate now has an optional property MaxPages that limits how many pages can be swiped with a single gesture
  • The method you've probably never heard about LayoutParams.Clone() has been split into TrueClone() and DeriveClone(). Contact @mortoray to find out which new method is suitable for you (The answer might surprise you!)
  • DrawContext.Current has been removed, calls to draw with DefaultShading must now specify the DrawContext meta-property
  • Video.ValueChanged has been removed, use Video.ProgressChanged instead
  • Stroke.StrokeAlignment has been renamed to Stroke.Alignment
  • Element now has an Aspect property, specifying the aspect for BoxSizing="FillAspect".

    This sizes the element based the avaialble size provided to it from its parent. The size of the content of this element is not considered in the sizing. For instance, this creates a square panel that is 20% the width of its parent:

      <Panel Width="20%" Aspect="1" BoxSizing="FillAspect"/>
  • DockPanel now support children specifying sizes (using %) relative to the entire container. This is a change from previously where such specifying a relative size on a child of a DockPanel would be equal to setting the property to 0.

    Note this also applies to items with Dock="Fill" (which is default). So if you previously used that to size relative to the remaining space you will have to wrap that in a Panel first to establish the new relative basis. For example:

          <Panel Width="50%">...


          <Panel><Panel Width="50%">...
Changes to the layout system
  • DefaultLayout no longer does two-pass sizing, only the maximum size of the first pass will be used to report its size. The previous two-pass was not numerically stable (each pass could produce larger and larger results, thus making 2 passes no better than 1)
  • StackLayout no longer does two-pass sizing by default. While there are scenarios where it can be required it doesn't come up often and it has a significant cost associated with it. If an element of your StackPanel (possibly the background) no longer has the correct size you can enable the two-pass mode with Mode="TwoPass".
  • In some situations if a Width and Height were specified on an element the Max/Min values would be ignored, thus allowing the element to violate those constraints. This has been fixed.
  • Node.GetMarginSize has a new signature float2 GetMarginSize(LayoutParams lp). The previous avilableSize is the Size property of that object, and the HasX and HasY property can be used to check for their existence.
  • Node.ArrangeMarginBox has a new signature float2 ArrangeMarginBox(float2 position, LayoutParams lp) as does OnArrangeMarginBox. This matches the change made to GetMarginSize.
  • The layout engine no longer does a second pass when enforcing Min/Max properties, it simply constrains the size. Elements that need to adapt based on the max/min must do so during the initial sizing request, as Image and Text now do. The LayoutParams has the maximum and minimum information inside it.
  • SizeFlags is removed, the user of LayoutParams removes the need for it

Layout now also makes a couple of assumptions:

  • SnapToPixels is expected to work only if all parent nodes/elements have this enabled as well. (At the moment it may still work without, but this is expected to change)
  • The arrangement of a node may not be dependent on its position, but only its size. So a 100x100 element has the exact same arrange at 50,75 as it does at 5,7. This is to support an optimal layout system of panels where the position may not be known before the size.
Improved iOS build customization

A few new iOS-specific attributes has been added to the project format:

"iOS": {
    "BundleIdentifier": "com.uno.$(Name)",
    "BundleName": "$(Title)",
    "DeploymentTarget": "7.0",
     "PList": {
        "MKDirectionsApplicationSupportedModes": [
        "UIRequiresPersistentWiFi": true,
        "UIRequiredDeviceCapabilities": [

The following plist property keys are currently supported: UIRequiredDeviceCapabilities, MKDirectionsApplicationSupportedModes, NSHealthShareUsageDescription, NSHealthUpdateUsageDescription, UIApplicationExitsOnSuspend, UIFileSharingEnabled, UINewsstandApp, UIPrerenderedIcon, UIRequiresPersistentWiFi, UISupportedExternalAccessoryProtocols, UIViewControllerBasedStatusBarAppearance, and UIViewEdgeAntialiasing.

A new UXL element called Xcode.EmbeddedFramework has been added for adding embedded frameworks to the generated Xcode project.

Absolute paths to frameworks in Xcode.Framework elements are now allowed. This means that the following ways to include frameworks are accepted:

<Require Xcode.Framework="some.framework" /> <!-- relative to SDKROOT/System/Library/Frameworks/ as before -->
<Require Xcode.Framework="/path/to/some.framework" /> <!-- absolute path -->
<Require Xcode.Framework="@('some.framework':Path)" /> <!-- relative to UXL file -->

The .framework extension is optional and will be added automatically if omitted.

Improved Android support

Uno projects can now be opened in Android Studio, making it easier to debug native code on device. Type uno build android --debug to launch Android Studio directly from the command line. Tested using Android Studio version 1.5 which can be downloaded from here: http://developer.android.com/tools/studio/index.html

  • New project structure

    In order to support Android Studio, we had to adapt to the new "Gradle" project structure, involving moving files around in the generated project. AndroidManifest.xml for example, can be found under @(Project.Name)/app/src/main instead of in the root output directory. Java source files are written to @(Project.Name)/app/src/main/java instead of src. Use the @(Java.SourceDirectory) macro to refer to the java source directory.

  • New APK launcher

    Some Windows users has been getting stuck on "Uninstalling APK" when trying to deploy APKs. This is usually because "Developer Mode" isn't enabled on the device, missing USB drivers, or the device is not properly connected. The new APK launcher is now able to print a better error message and terminate, instead of getting stuck.

    The new launcher will also print logcat output from the device while app is running.

    See uno launch-apk -h for more. You can pass launch-apk options through uno build android -a"OPTIONS".

  • Added ADB wrapper

    You can use uno adb [args] if you need to run adb from the Android SDK without adding "platform-tools" to PATH.

  • Added Android SDK Manager wrapper

    You can use uno android if you need to open the Android SDK Manager.

  • Improved "space support", so Android users can enjoy...

    • ...projects containing spaces in the name
    • ...projects containing spaces in the path
    • ...Android SDK and NDK installed in a location containing spaces in the path
  • New Uno project settings for SDK configuration

    If you have specific requirements regarding SDK, you can now control those with the following properties:

      "Android": {
        "NDK": {
          "PlatformVersion": null     // default: 9
        "SDK": {
          "BuildToolsVersion": null,  // default: 23.0.0
          "CompileVersion": null,     // default: 19
          "MinVersion": null,         // default: 10
          "TargetVersion": null       // default: 19

    We do however recommend to keep null for automatic detection of settings based on the current SDK installed on the build machine (fuse install android).

  • Fixed a problem causing mkdir to sometimes fail on Windows

  • Updated native compilers to GCC 4.9
Uno command line interface changes
  • The following targets were renamed, but you can still use the old name:

    New name Old name
    DotNet DotNetExe
  • The --debug argument is supported by the following targets:

    Build target Action
    Android Opens Android Studio
    CMake Opens Xcode (OS X only)
    iOS Opens Xcode (OS X only)
    MSVC Opens Visual Studio 2013 (Windows only)

    If the project is already open in an IDE/debugger, we won't open any additional windows. You can use --debug as often as you want without being worried about getting spammed by new windows.

    --debug will disable the native compile step in Uno, and enable native debugging, so that you can build and debug from the IDE. Otherwise --debug is short hand for --run-args=debug, and will pass debug as an argument to the run script. This may fail without error if used on an unsupported build target.

  • Specify target without --target

    For example, to build for Android:

      uno build android
  • Added new shorthand arguments:

    • -N -> --no-native (Disable native compile step)
    • -S -> --no-strip (Disable removal of unused code)
    • -d -> --debug (Open IDE for debugging)
  • C++ debugging flags can be passed on the command line:

    • -DDEBUG_UNSAFE (Enable asserts in unsafe code)
    • -DDEBUG_ARC1..4 (Print debug info from memory manager)
    • -DDEBUG_DUMPS (Dumps object graphs to disk for analysis)
UXL changes
  • New macro operators

    Macro Input Output
    @(FOO:EscapeSpace) foo bar foo\ bar
    @(FOO:QuoteSpace) foo bar "foo bar"
  • Tolerant XML syntax

    The UXL parser is able to handle attributes and inner text containing non-encoded XML entities. Quotes are optional on simple attribute values, such as numbers and booleans. For example, this is now accepted by the parser:

      <Define UNIX />
      <Set Foo=1 Condition="FOO && BAR" />
      <Expression>a < b</Expression>
      <Expression>a < b</Expression>

    Instead of, compared to strict XML:

      <Define UNIX="UNIX" />
      <Set Foo="1" Condition="FOO && BAR" />
      <Expression><![DATA[a < b]]></Expression>
      <Expression>a < b</Expression>

Download this version

Fuse 0.9.7

This is a bugfix release that fixes a problem where we failed to find Java Development Kit in Fuse 0.9.6.

Known bugs

If this is the first time you install Fuse, or if you get the message Unable to resolve project target 'android-19', you have to run the following command to be able to build for Android:

android update sdk -s -u -a -t platform-tools,build-tools-23.0.2,android-19,android-21

To find the location of the android command, please run fuse install -s android, and look for the folder called AndroidSDK/tools.

For a more detailed guide, please have a look at Installing android-19 support in Fuse.

Download this version

Fuse 0.9.6

Improved SDK Downloader
  • Fixed bugs related to having Java in custom path
  • It will now try to find 3rd-party packages in common places, as in environment PATH variable etc.
  • Android platform API 21 will now be installed (required so that latest android play libraries works). Please run fuse install android again if you happens to have problems with android play libraries.
LoadHtml HTML
  • LoadHtml now takes an <HTML> node for inline HTML like the WebView for consistency.
Text/TextInput LineSpacing
  • We now respect LineSpacing on Android and iOS
Opacity threshold
  • Elements with a low opacity now remain hittable, previously they would stop being hit targets. This change allows a way for invisible things to receive hits, which was previously not possible (as well as removing a suspicious behaviour). The HitTestOpacityThreshold has also been removed. To make an item non-hittable use one of the alternatives: Visibility="Hidden", HitTestMode="None" or IsEnabled="false".

For example, if you had a a trigger like this:

    <Change Myself.Opacity="0"/>

And relied on it becoming unhittable, you must now explicitly disable it and/or make it truly invisible:

    <Change Myself.Opacity="0"/>
    <Change Myself.Visibility="Hidden"/>
    <Change Myself.IsEnabled="false"/>

Setting things invisible and disabled also enables some performance gain in the application.

  • LimitHeight and LimitWidth are now style properties of Element directly, not attached properties. If you referred to them with the LimitBoxSizing prefix drop that from the UX files. In Uno the style properties are inside Element now.
  • The default unit of LimitHeight and LimitWidth is now Points to be consistent with other unit based notations. You must add a % to the value if this is what was expected 100%.
  • Cleanup and add fallback in case a root view-port is not found.
Android TextRenderer
  • A crash-bug when the Value property was null has been fixed.
Element caching
Known bugs
  • If your .unoproj contains a space, you might not be able to build for Android
  • GeoLocation can cause local preview to crash

Download this version

Fuse 0.9.5

Improved Sketch-document importer
  • Better handling of spaces and dashes in paths
  • Improved font resolving
  • Fixed an issue causing import to fail when no font was specified in the Sketch-document
  • Fixed a couple of issues where the Sketch importer could generate illegal code (illegal identifiers)
  • The bug causing "Error creating standard error pipe" on some larger projects has also been fixed
  • Improved error message if you don't have either Sketch or Sketchtool installed
  • ContainingText is a deprected name, use WhileContainsText instead
  • WhileContainsText now works on any IValue<string>, such as the base TextControl, not just a TextInput
  • BoxSizingMode.Shadow renamed BoxSizingMode.LayoutMaste to be consistent with class. This does not affect any UX code.
  • Setting LayoutMaster to null reverts to the standard box-sizing model for the element
  • Several globals were moved from LayoutAnimation into LayoutTransition to allow reuse elsewhere. This should not require any UX change as the global names have not changed. Uno change will require using the other class name LayoutAnimation.PositionLayoutChange => LayoutTransition.PositionLayoutChange.
  • ITranslationMode, IScalingMode, IResizeMode derive from ITransformMode now and have a Flags property. If you should happen to have one in your code you can simply return TransformModeFlags.None
  • New TransitionLayout action
  • New TransformOriginOffset for Translation.RelativeTo. Provides a distance, in local space, between the TransformOrigin of the source Node and the RelativeNode. It expects Element for both nodes (will use a 0,0 origin if not an element)
  • New PositionOffset for Translation.RelativeTo. Provides a distance, in local space, between the position of the two nodes.
  • New SizeFactor for `Scaling.RelativeTo". Provides the ratio in sizes between the two Element's. This allows scaling one element to be the size of another.
Uri.Encode and Uri.Decode
  • Change Uri.Encode and Uri.Decode to treat space as %20, like RFC 2396 and the rest of the world agrees on.
  • Change Uri.Encode to not percent-encode tilde and single quotes, in accordance with RFC 2396.
  • Make Uri.Encode and Uri.Decode grok UTF-8.
Project meta data / rotation
  • Fixed issue where project metadata was not written out to target platforms. This fixes the issue some had with "Orientation" : "Portrait".
Known bugs
  • If your .unoproj contains a space, you might not be able to build for Android
  • GeoLocation can cause local preview to crash

Download this version

Fuse 0.9.4

  • Introducing UX properties to make it easier to create components in pure UX (trust us, you'll love this)
  • Several improvements to the layout and animation system
  • Easier to load HTML in a WebView
  • New WhileWindowSize trigger (do things when the window dimensions change)
  • Improved and extended DebugAction for easier.. well, debugging
  • Android videos now work way better with backgrounding and other apps playing audio
  • Lots of improvements to Uno, especially the C++ backend
Introducing ux:Property

The UX-compiler has been improved with a new feature that allows parameterization of ux:Classes. This is done by exposing values as settable properties on the generated class with the ux:Property syntax. This makes it easier to create more powerful reusable components.

Here is a quick example:

<App Theme="Basic" >
    <Panel ux:Class="MyButton" ux:Name="self">
        <string ux:Property="Text" ux:Value="MyButton" />
        <float4 ux:Property="CornerRadius" ux:Value="0" />
        <float4 ux:Property="BackgroundColor" ux:Value="#f00" />
        <float4 ux:Property="TextColor" ux:Value="#000" />
        <Text Alignment="Center" TextColor="{Property self.TextColor}" Value="{Property self.Text}"/>
        <Rectangle Layer="Background" CornerRadius="{Property self.CornerRadius}">
            <SolidColor Color="{Property self.BackgroundColor}"/>

    <MyButton CornerRadius="20" Text="MyText" TextColor="#fff"
              BackgroundColor="#5C6BC0 " Width="200" Height="50"/>

In many cases where you would previously use resource- or data-binding as a way of passing data to a ux:Class, you can now use ux:Property to design a nice interface for your components.

Note that ux:Property currently only works for atomic types (e.g. float4 and string) and not for complex class types. This is being improved in an upcoming version.

New triggers
  • Added WhileWindowSize trigger that lets you gate on window dimensions (in points). This element supports GreaterThan, LessThan and EqualTo, all taking a two component vector (float2). E.g. <WhileWindowSize GreaterThan="640,480" LessThan="1280,720">
  • Added OnKeyPress trigger taking a Key value
  • Added OnBackButton OnKeyPress extension with BackButton preset to capture Android back button event
Changes to layout
  • StackPanel and StackLayout now handle oversized content differently. It has a ContentAlignment parameter which decides how to align that content, and defaults to match the alignment of the panel itself. (Only alignment in same direction as the orientation of the panel is supported).

    This means the alignment of some old code could change if the content was too big for the containing panel. The old behaviour was equivalent to ContentAlignment="Top" or ContentAlignment="Left" (depending on Orientation).

    The new defaults are considered to be the correct behaviour and this is considered a bug fix.

  • Grid and GridLayout have the same change as StackLayout, though it supports all non-default alignments for ContentAlignment.

  • The Layout constructor and several of its functions are now internal. They were not intended to be public before as it is an internal mechanism. The high-level layout specification remains as-is (all UX code remains unaffected).
  • removed unused DrawCount facility
  • LimitBoxSizingData has been removed. The properties LimitWidth and LimitHeight can now be placed directly on the element. Units use the usual syntax: <Panel LimitWidth="100%"/>
Extended WebView API
  • Added Source and BaseUrl attributes for loading html source via databinding in the context of a base url (use depends on platform though both android and ios webkit views use the same concept).
  • Added LoadHtml Action for telling a webview to load html source from a string and a baseurl.
  • Added HTML node for WebView letting you cdata inline html as such:
              <h1>Hello world</h1>
UX debugging features
  • DebugAction no longer outputs time and frame by default in addition to its Message.
  • DebugAction can contain certain debug nodes. For now these are DebugProperty, DebugTime and DebugFrame
  • DebugTime outputs the current application time
  • DebugFrame outputs the current total frame count
  • DebugProperty takes a Tag string identifier and a Value property string (like Change and Set) and prints that current value prefixed with the Tag
  • A DebugAction without a Message only prints its child debug nodes if any.
Introducing unstyled TextEdit class
  • TextEdit is introduced as an unstyled text input type. Most things (ex. triggers) that accepted a TextInput before now accept a TextEdit.
  • TextInput is now derived from TextEdit
  • The namespace Fuse.Controls.TextEdit is renamed Fuse.Controls.FallbackTextEdit to avoid collision and be clearer as to its purpose
Improved animation system
  • The setter HierarchicalNavigation.ReuseExistingNode now correctly uses the provided value (previously it just assigned false)
  • Some parts of the animation system have been marked internal; they were incorrectly marked as public before. They cannot be supported in the manner they were exposed. It's unlikely to impact any user code.
  • TriggerAnimation.GetTotalDuration renamed TriggerAnimation.GetAnimatorsDuration to avoid conflict/confusion with what it does and a new time scaling feature
  • Cycle gains the Waveform option. Of particular interest is Sawtooth which animates in one direction in a linear fashion
  • Transform now has an internal constructor. User classes are not supported as it's important internally to have a controlled list.
  • INavigation.ActivePage added to return the currently active page. This fixes some issues using DirectionNavigation and PageBinding.
  • LayoutChanged has been removed, leaving only Placed. It also does not contain any previous world information, as it was not possible to derive in a consistent fashion. An interested listener must use Preplacement instead, but generally this is all part of an internal mechanism that should not be used in user code.
Introducing FuseJS/Environment API

You can now do require("FuseJS/Environment") in JavaScript to get access to platform conditionals.

Lots of C++ improvements

The C++ code generator has more or less been rewritten for this release, and the underlying C++ APIs has been cleaned up along with it. This doesn't affect regular Uno code or UX markup, but may affect handwritten code using the C++ APIs directly.

However, this rewrite wasn't just for fun; it also gives us some cool new (advanced) features!

  • Partial reflection support in Uno.Type

    Almost 30 new members are introduced in Uno.Type, modelled after System.Type in .NET. This enables runtime generic type support.

  • Runtime parameterization and reflection of generic classes and methods

    This gives 100% code sharing between generic parameterizations, reducing the amount of C++ code generated by 30-40% (default Fuse project, --no-strip, MSVC12)

    Creation of new type parameterizations at run time will also make the fuse preview more robust, as it no longer relies on having parameterizations available at compile-time. This is what have been causing occasional "type not found" errors when attempting to animate certain properties.

    The new C++ APIs powering this are found in the Uno/ObjectModel.h header.

  • General dynamic invoke

    Any Uno method can be invoked by function pointer using a single C++ function: void uInvoke(const void* func, void** args, size_t count). To make this possible we've changed the calling convention when using function pointers. All function pointers must return void while any parameters and return value is passed by pointer. This allowed us to remove a lot of C++ template clutter, enabling faster compilation and better code.

  • Less call stack clutter

    Previously nearly all method calls resulted in two entries in the call stack because of wrapping. Now there's just one entry for common method calls, when not being invoked using a delegate or interface. This should help make the call stacks less deep and easier to navigate. Many generated methods also get cleaner C++ names (Object::New() vs. Object__New()).

  • Various runtime performance improvements

    Most compiler-generated runtime hash look-ups have been eliminated. This fixes serious performance problems in some cases, for example in code where string constants are used heavily. In addition, interface look ups are optimized to O(log n) instead of O(n) when calling methods or using the is and as operators.

  • Use array initializers in generated code

    Emit array initializers, e.g. uArray::Init<int>(Int__typeof(), 2, 0, 1), instead of unrolling the expression and setting all the elements individually. This makes the generated C++ code smaller and easier to read.

  • Type initializers

    Implement runtime support for type initializers, instead of generating code using a compiler transform. This enables support for static generic fields, and generates somewhat cleaner and better behaving code. Static constructors are invoked lazily and are called before accessing a static member on the declaring type, or instantiation an object of the type.

  • Less Xcode warnings are produced when building for iOS and OS X

  • Uno is now aware of keywords and other reserved words in the target language, and will rename identifiers as necessary to avoid conflicts.
C++ API changes
  • Most notably, the following methods were changed in Uno/ObjectModel.h:
New methodOld method
uArray::New(arrayType, length, [data])uNewArray(elementType, length, [data])
uString::Ansi(cstr, [length]) uNewStringAnsi(cstr, [length])
uString::Utf8(cstr, [length]) uNewStringUtf8(cstr, [length])
uString::Const(cstr) uGetStringConst(cstr)

Note that uArray::New() now expects arrayType directly rather than elementType, for better cache usage.

And these methods in Uno/Memory.h:

New methodOld method
uRetain(object) uRetainObject(object)
  • Some fields were given better names. For example, uArray::_len -> _length.

  • Xli.h, the all including header, was removed. Include a more specific header instead. For example Xli/Mutex.h. Just ask in #uno on our Slack community if you need help.

Test runner improvements
  • Added timers, printing how many microseconds (μs) spent running each test, in addition to total time spent building and testing.
  • Less verbose output. Only warnings (if any) and STDERR are printed from the build log. Use -v if you need more output.
  • Tests are now run in alphabetical order
Smaller installer footprint and stuff™

Platform specific binaries (Xli, V8, FMOD, ...) used by Uno packages are no longer included in the installer, but downloaded on demand if needed during build. This enables us to remove some large and not-always-needed binary files from the installer, making the download ~30MB smaller on each platform. This also introduces uno stuff, a simple built-in package manager.

Uno tooling improvements
  • Fix launching Xcode simulator on iPhone 6. Previously only older generations worked
  • Integrated uno doctor, test, perf-test and perf-cmp commands

    uno doctor replaces StdLibBuilder. Use whenever the package library needs updating. In addition, the --libs switch can be used on uno build to update on demand. The redundant unotest and performancetest commands were removed -- use uno test and uno perf-test instead.

  • Append to path arrays in .unoconfig

    Personal/project specific .unoconfig files can now append additional paths using $(LastPathArray). For example:

      PackageSearchPaths: [
      PackageBuildPaths: [
  • The build log now produces minimal output by default. Add -v, -vv or -vvv when using the uno command if you need more output.
  • uno --version will now present the correct version. Kinda important we think.
UXL changes
  • Array macros

    • Create arrays using @{ELEMENT_TYPE:Array([ELEMENTS, ...])} or @{ELEMENT_TYPE[]:New(SIZE)}
    • Access elements using @{ARRAY:Get(INDEX)} and @{ARRAY:Set(INDEX, VALUE)}
  • Renamed C++ specific elements and properties

    The old names will generate a warning when used. Just replace with the new name for silence.

New nameOld name
  • Renamed CIL specific properties

    The old names will generate a warning when used. Just replace with the new name for silence.

New nameOld name
  • Preprocessor improvement

    #if..#endif directives will expand to comments containing the disabled code instead of blank lines, when false.

Other fixes
  • Setting Text.TextWrapping=NoWrap with Native theme will no longer lead to text-wrapping on iOS
  • Add iOS.BundleVersion project property to set plist property CFBundleVersion on iOS
  • Sending Android apps to the background will now pause/resume any playing Videos.
  • Playing a video on Android while other music is playing on the device will now acquire audio focus and stop other audio.
  • Fixed the Context vs. NavigationContext property naming inconsistency. The NavigationContext property should now be used on target navigation triggers (WhileCanGoBack and WhileCanGoForward).
  • Bitwise operators now have correct return type. This affects the following types: byte, sbyte, short and ushort.
  • Fixed a bug where passing a reference field through ref or out didn't work, and some other cases of valid code that didn't compile.
  • Generated C++ code built in release by default. Uno code is still built in debug by default. Specify -O0 to unofor unoptimized build when debugging.
  • iOS: Passing --run to uno build now runs the project directly on a connected device. Adding -adebug brings up the Xcode project as before.
  • MSVC12: The -adebug flag is also supported on the msvc12 target, opening up Visual Studio for debugging instead of running the executable.

Download this version

Fuse 0.9.3

This is a hotfix release for 0.9.2.

It fixes a bug that was only on OS X, and only if 0.9.2 was the first version of Fuse you installed. The main symptom was that the recent projects list in the OS X dashboard was always empty.

If your recent projects list is not empty, you can safely skip this version.

Download this version

Fuse 0.9.2

Video now works on desktop

This release brings Fuse.Video to the desktop, and it now works in preview on both Windows and Mac OS X. Under the hood this uses DirectShow on Windows and AVPlayer on OS X.

Layout animations
  • LayoutArgs.PositionChange is renamed to WorldPositionChange and gains OldPosition and NewPosition
  • LayoutAnimation.GetPositionChange has been made internal (it should not have been exposed before)
  • RelativeTo="LayoutChange" should no longer be used and will be removed. Use instead the specific WorldPositionChange or SizeChange depending on which animator
  • PositionChange is also added as a RelativeTo option, but refers specifically to the position within the parent (non-global changes)
  • A new Released trigger that pulses when a pointer is released in the node (without capture or previous down event)
  • WhilePressed.Capture allows a false option (default true) to not capture the mouse to track the trigger. It will be active so long as the pointer is within the element and pressed.
Workflow for working with Uno-code

Changes to Uno-code no longer requires exiting Fuse entirely to take effect. Just close all open preview windows/apps that are previewing the project, and the next time you do fuse preview it will use your latest Uno-code.

Improved Sketch-importer
  • Generated code is now indented with a tab character (instead of a single space)
  • Generated Page-tags now has the default HitTestMode, allowing you to select things within a page, not just the page itself
  • Fixed wrong relative path to FileImageSources in generated code
  • Fixed various bugs causing UnauthorizedAccessException and scary stack traces
  • Fixed crash when importing text without a color set
  • Fixed escaping of quotes in text
  • Fixed an issue where the sketch importer would fail due to missing an existing font file
  • Fixed an issue where using System Font Regular would generate invalid code
  • Fixed bug causing invalid namespace names in generated code
Fuse tools
  • You no longer have to wait for the spinning thing under "Recent projects" in the OS X dashboard
  • Introducing the fuse daemon-client command, making life a bit easier for everyone making plugins for Fuse (API docs will follow shortly!)
  • Introducing the fuse kill-all command, shutting down all fuse processes (We hope you don't have to use it, though)
  • OS X installer will now kill old fuse processes
Known bugs
  • Using the GeoLocation api on iOS 7 results in the app crashing.

Download this version

Fuse 0.9.1

This is primarily a bugfixing and stabilizing release.

OS X only: make sure you quit Fuse from the OS X menu bar before installing/restarting Fuse.

TextInput placeholder
  • TextInput now has PlaceholderText and PlaceholderColor properties, to show descriptive text in these while empty.
MaxWidth/Height change
  • The implied 100% MaxWidth/Height is no longer implied if a corresponding Width/Height parameter is specified. This means that an element with a Width parameter is no longer constrained to its parent width by default, and a one with a Height parameter is not constraint to the parent height by default. This affects only a small fraction of layouts, resulting in larger elements. If you need the old behaviour on an element just add back in the explicit MaxWidth/Height property:

    <Panel ... MaxWidth="100%" MaxHeight="100%">


Added a FuseJS/HttpClient, this fixes a lot of bugs in XMLHttpRequest and fetch.

Various bugfixes
  • Fixed bugs related to multiple users of Fuse on same machine.
  • Fixed failing iOS export as reported here.
  • Fixed a bug where preview would sometimes get stuck at "Host is loading project"
  • Several minor bugfixes and stability improvements

Download this version

Fuse 0.9.0

Introducing Fuse.Video

Added support for video playback on mobile export targets. Video can be played from file or a network stream. Video format support is dependent on the specific device and OS you are exporting for:

Introducing media playback triggers

We realized that for the video element to be useful we needed some new triggers, so in this release we are also introducing WhilePaused, WhilePlaying and WhileCompleted. These triggers are designed to be usable with any media playback element, which will be expanded in future revisions.

Introducing push notifications API

We now support push notifications on iOS and Android. Notifications can be recieved from GCM (for Android) and APNs (for iOS).

Introducing GeoLocation API

Never get lost again! A cross platform geolocation API is now available in the FuseJS/GeoLocation JavaScript module. It's also really easy to use:

var GeoLocation = require('FuseJS/GeoLocation');

var locationOrNull = GeoLocation.location;
var locationPromise = GeoLocation.getLocation();

GeoLocation.onChanged = function(location) { ... };
Extended WebView API
  • Added WhileLoading, PageBeginLoading and PageLoaded triggers
  • Added GoBack, GoForward and Reload triggers which take a WebView argument to point at a specific view
  • Added LoadURL trigger action for telling a webview to go to a certain url with WebView and Url args
  • Added EvaluateJS trigger action for executing arbitrary JavaScript within a webview context and optionally passing the stringified JSON result of the evaluated JavaScript to a FuseJS callback
  • Removed <WebView File="someFile"/> in favor of using file:// protocol with <WebView Url="file://someFile"/>

Read more in the handbook.

Preview improvements
  • Improved stability of the simulator host, i.e. less "preview stopped responding to my changes"-issues
  • That mysterious devices.json-file is now optional. When it's not present the default device presets are loaded
  • Changes to devices.json are now automatically reflected in preview (What do you think we are? Ancient technology?)
  • Just to show off the above feature we also added a "Customize..." option in the bottom of the Device menu, opening devices.json in your favourite text editor (as long as your favourite text editor is the default for .json files)
  • Not to forget: Opening the monitor just got easier. This release features a brand new "Open monitor" option, inside of preview. Never again use the command line or other cumbersome launchers to do as we say when we tell you to open the monitor, just choose Fuse -> Open monitor in preview, or enjoy the shortcuts Ctrl+M and CMD+M, for improved productivity.
  • We also added a brand new "Project" menu, providing shortcuts to the included UX-files, the project file, and the containing project folder
  • Are other windows constantly trying to cover your preview window? Did you leave your extra monitor at home? Try our new "Keep on top" feature in the Fuse menu today!
TextInput primary keyboard action

You can now react to the primary keyboard action on a TextInput. Use the ActionTriggered property to specify a callback or use TextInputActionTriggered trigger.

<TextInput ActionStyle="Search" ActionTriggered="{goSearch}">

The ActionStyle property selects what the standard action button on the keyboard displays.

TextInput completeness and polish

Multiline text input is now supported on iOS. If we could think of anything to add here we would now have written multiple lines about this fix.

Android NativeTheme improvements
  • A bug where changing the value of a Text element did not cause the text to resize has been fixed.
  • Transforms in Fuse have top/left as their default origin, but there was a bug causing Android views to have center as their default transform origin. We like consistency in our APIs so this release makes the misbehaving views conform to the top/left default transform origin.
  • To avoid potential confusion with effects the ShadowBoxSizing has been renamed LayoutMasterBoxSizing. In particular, the ShadowElement property is not LayoutMaster.
  • ButtonText is no longer in the global namespace (that was an error), it is now Fuse.BasicTheme.ButtonText as it is theme specific. If you used ButtonText somewhere you need to replace that with Fuse.BasicTheme.ButtonText
  • The UpdateManagerclass now has a PostAction, which collects actions to be run prior to primary update. The dispatcher now uses this mechanism to avoid mixing the actions with the deferred actions.

Download this version

Fuse 0.8.5


  • V8: We now use the V8 JavaScript engine on Android. This is faster, and enables debugging.
  • Selection in preview: When working with the inspector, you can now select the item to work on directly from the preview window (Preview -> Fuse -> Design mode)
  • TextInput: Several improvements and fixes to text input
  • Bundled mono: Mono is now bundled with Fuse, you no longer have to install it manually.


  • Mono is now bundled with Fuse.
  • Exceptions from Uno in local preview shows callstack in Fuse monitor.
  • Added support for NDK10e.
  • Introducing "Design mode" (Preview -> Fuse -> Design mode), in which you select things for use in the inspector by clicking on them visually.
  • It is now possible to quit the inspector from the menu or using CMD+Q on Mac OS X.
  • Some issues causing the simulator to stop auto-reloading your changes have been fixed
  • Improved some error messages


TextInput completeness and polish
  • Multiline textinput on iOS implemented
  • Better integration of textinput on mobile export targets, native focus cooperates with fuse focus to request and dismiss the keyboard
  • A NativeViewHost is now required with the Graphics or Basic theme to create native only controls such as WebView. For example:

             <WebView Url="https://fusetools.com"/>

Previously a WebView would work directly in the graphics themes. This was not desired as we wished to make clear the special status of these controls.

  • Fuse.iOS.Controls.WebView and Fuse.Android.Controls.WebView should not be used anymore, and previous code using them will likely fail now. Use the above setup to get a native WebView.
  • NativeViewHost no longer inherits any style from its parent nodes. It uses the platform basic style and does not cascade upwards. You will have to add styles to the Node to have them apply to items inside of it.
Android NativeTheme Text alignment
  • A bug where changing the value of a Text-element did not cause the text to resize has been fixed.
FuseJS Observable.insertAt
  • observable.insertAt(index, value) inserts a value at a specific index in an Observable.
  • We now use the V8 JavaScript engine on Android. This enables JavaScript debugging on Android and is faster than the previous JavaScript engine.
FuseJS Observable.map
  • The map function on Observables now accepts a function with an optional index parameter, as in observable.map(function (x, i) { return x + " has index " + i }).


  • Add Xcode.FrameworkDirectory UXL element

Download this version

Fuse 0.8.4


  • Improved support for OS X Mavericks.
  • Improved status bar in OS X Dashboard with integrated build log viewer that can be toggled by clicking the status bar itself.
  • Updates to OS X first-run experience to clarify that Sublime Text is not required, and also changing the wording in the Sublime Text setup wizard to clarify that exiting it does not exit the Dashboard entire.
  • Update checks are now daily rather than constant on OSX, unless forced by choosing "Check for updates" from the tray menu.
  • Guarded against possible issue where exiting Fuse from the OS X tray menu might not kill the correct Fuse process, leaving a zombie daemon.
  • Added support for custom Android SDK, Android NDK, Ant and Java paths in our installer.
  • Monitor will now show messages sent before it was started (5 min buffering).
  • You can now add and remove shadows on any Fuse Element from the inspector (Experimental).


  • LayoutChange in the Move and Resize animators now requires that X and Y (or Vector) are specified. It previously assumed those values were 1 which is a defect, and was not intended to work. The default is 0 meaning the transform will have no effect.
    <Move RelativeTo="LayoutChange"/>
    <Resize RelativeTo="LayoutChange"/>


    <Move RelativeTo="LayoutChange" Vector="1"/>
    <Resize RelativeTo="LayoutChange" Vector="1"/>

This is to facilitate values other than 1 during layout transitions (for example, to animate X and Y independently).

  • IResizeMode.GetSizeChange has new parameters, expressed as a base size and delta instead of old and new size.
  • Node.IsRooted has a new meaning now. It becomes true only after the OnRooted function is called on the Node. This is most likely what code meant when checking this status, thus no change is anticipated to be necessary.
  • Rooting stages are now clearer and children will not be rooted until their parent is essentially finished rooting.
  • Fuse.iOS has been restructured for clarity. Native views are now in the Fuse.iOS.NativeViews namespace and leaf implementations are in the Fuse.iOS.Controls packages, where the names match the Fuse control of the same name.
  • Uno.GraphicsContext is deprecated and should no longer be used. Use only DrawContext to retain a consistent GL state.
  • DrawContext.ViewportPixelSize renamed to GLViewportPixelSize to better reflect what it is -- as it is not the same as the IViewport.PixelSize in all situations. You should avoid using the GLVuiewportPixelSize, it usually isn't the value actually wanted.
  • Fixed: multi-line text-input on iOS. Earlier, the multi-line flag was ignored on iOS.
  • Fixed: custom fonts in simulator should now load correctly.


  • Replaced IPAdddress.IPAddress(string) with IPAddress.Parse(string)

Download this version

Fuse 0.8.3

This release fixes an issue where some users would make changes to .ux files that were not reflected in preview.

Download this version

Fuse 0.8.2

This release fixes issues with building for Android and iOS.

Download this version