diff --git a/.ncrunch/Avalonia.LinuxFramebuffer.v3.ncrunchproject b/.ncrunch/Avalonia.LinuxFramebuffer.v3.ncrunchproject
new file mode 100644
index 00000000000..6800b4a3fec
--- /dev/null
+++ b/.ncrunch/Avalonia.LinuxFramebuffer.v3.ncrunchproject
@@ -0,0 +1,5 @@
+<ProjectConfiguration>
+  <Settings>
+    <PreviouslyBuiltSuccessfully>True</PreviouslyBuiltSuccessfully>
+  </Settings>
+</ProjectConfiguration>
\ No newline at end of file
diff --git a/.ncrunch/Avalonia.Visuals.UnitTests.net461.v3.ncrunchproject b/.ncrunch/Avalonia.Visuals.UnitTests.net461.v3.ncrunchproject
new file mode 100644
index 00000000000..6800b4a3fec
--- /dev/null
+++ b/.ncrunch/Avalonia.Visuals.UnitTests.net461.v3.ncrunchproject
@@ -0,0 +1,5 @@
+<ProjectConfiguration>
+  <Settings>
+    <PreviouslyBuiltSuccessfully>True</PreviouslyBuiltSuccessfully>
+  </Settings>
+</ProjectConfiguration>
\ No newline at end of file
diff --git a/.ncrunch/Avalonia.Win32.Interop.v3.ncrunchproject b/.ncrunch/Avalonia.Win32.Interop.v3.ncrunchproject
new file mode 100644
index 00000000000..6800b4a3fec
--- /dev/null
+++ b/.ncrunch/Avalonia.Win32.Interop.v3.ncrunchproject
@@ -0,0 +1,5 @@
+<ProjectConfiguration>
+  <Settings>
+    <PreviouslyBuiltSuccessfully>True</PreviouslyBuiltSuccessfully>
+  </Settings>
+</ProjectConfiguration>
\ No newline at end of file
diff --git a/samples/ControlCatalog/MainWindow.xaml.cs b/samples/ControlCatalog/MainWindow.xaml.cs
index c7c61e2b4ea..413794dfa2a 100644
--- a/samples/ControlCatalog/MainWindow.xaml.cs
+++ b/samples/ControlCatalog/MainWindow.xaml.cs
@@ -10,6 +10,7 @@ public MainWindow()
         {
             this.InitializeComponent();
             this.AttachDevTools();
+            Renderer.DrawDirtyRects = Renderer.DrawFps = true;
         }
 
         private void InitializeComponent()
diff --git a/samples/interop/Direct3DInteropSample/Program.cs b/samples/interop/Direct3DInteropSample/Program.cs
index 7fb650a7a8b..d5de5ccb4ed 100644
--- a/samples/interop/Direct3DInteropSample/Program.cs
+++ b/samples/interop/Direct3DInteropSample/Program.cs
@@ -11,7 +11,7 @@ class Program
     {
         static void Main(string[] args)
         {
-            AppBuilder.Configure<App>().UseWin32().UseDirect2D1().Start<MainWindow>();
+            AppBuilder.Configure<App>().UseWin32(deferredRendering: false).UseDirect2D1().Start<MainWindow>();
         }
     }
 }
diff --git a/src/Android/Avalonia.Android/AndroidPlatform.cs b/src/Android/Avalonia.Android/AndroidPlatform.cs
index e9b4ad0a6d2..7134e7d1b42 100644
--- a/src/Android/Avalonia.Android/AndroidPlatform.cs
+++ b/src/Android/Avalonia.Android/AndroidPlatform.cs
@@ -52,13 +52,11 @@ public static void Initialize(Avalonia.Application app)
                 .Bind<IStandardCursorFactory>().ToTransient<CursorFactory>()
                 .Bind<IKeyboardDevice>().ToSingleton<AndroidKeyboardDevice>()
                 .Bind<IPlatformSettings>().ToConstant(Instance)
-                .Bind<IRendererFactory>().ToConstant(ImmediateRenderer.Factory)
                 .Bind<IPlatformThreadingInterface>().ToConstant(new AndroidThreadingInterface())
                 .Bind<ISystemDialogImpl>().ToTransient<SystemDialogImpl>()
                 .Bind<IWindowingPlatform>().ToConstant(Instance)
                 .Bind<IPlatformIconLoader>().ToSingleton<PlatformIconLoader>()
                 .Bind<IRenderLoop>().ToConstant(new DefaultRenderLoop(60))
-
                 .Bind<IAssetLoader>().ToConstant(new AssetLoader(app.GetType().Assembly));
 
             SkiaPlatform.Initialize();
diff --git a/src/Android/Avalonia.Android/Platform/SkiaPlatform/TopLevelImpl.cs b/src/Android/Avalonia.Android/Platform/SkiaPlatform/TopLevelImpl.cs
index 0c62eb90602..6c8db17c71d 100644
--- a/src/Android/Avalonia.Android/Platform/SkiaPlatform/TopLevelImpl.cs
+++ b/src/Android/Avalonia.Android/Platform/SkiaPlatform/TopLevelImpl.cs
@@ -13,6 +13,7 @@
 using Avalonia.Android.Platform.Input;
 using Avalonia.Controls;
 using Avalonia.Controls.Platform.Surfaces;
+using Avalonia.Rendering;
 
 namespace Avalonia.Android.Platform.SkiaPlatform
 {
@@ -85,7 +86,12 @@ public virtual Size ClientSize
         public IPlatformHandle Handle => _view;
 
         public IEnumerable<object> Surfaces => new object[] {this};
-        
+
+        public IRenderer CreateRenderer(IRenderRoot root)
+        {
+            return new ImmediateRenderer(root);
+        }
+
         public virtual void Hide()
         {
             _view.Visibility = ViewStates.Invisible;
diff --git a/src/Avalonia.Controls/Platform/ITopLevelImpl.cs b/src/Avalonia.Controls/Platform/ITopLevelImpl.cs
index ba3ecb99c56..60e25d2be65 100644
--- a/src/Avalonia.Controls/Platform/ITopLevelImpl.cs
+++ b/src/Avalonia.Controls/Platform/ITopLevelImpl.cs
@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using Avalonia.Input;
 using Avalonia.Input.Raw;
+using Avalonia.Rendering;
 using JetBrains.Annotations;
 
 namespace Avalonia.Platform
@@ -60,6 +61,12 @@ public interface ITopLevelImpl : IDisposable
         /// </summary>
         Action<double> ScalingChanged { get; set; }
 
+        /// <summary>
+        /// Creates a new renderer for the toplevel.
+        /// </summary>
+        /// <param name="root">The toplevel.</param>
+        IRenderer CreateRenderer(IRenderRoot root);
+
         /// <summary>
         /// Invalidates a rect on the toplevel.
         /// </summary>
diff --git a/src/Avalonia.Controls/TopLevel.cs b/src/Avalonia.Controls/TopLevel.cs
index a0a8f6b27eb..f8db0e2a5be 100644
--- a/src/Avalonia.Controls/TopLevel.cs
+++ b/src/Avalonia.Controls/TopLevel.cs
@@ -90,8 +90,7 @@ public TopLevel(ITopLevelImpl impl, IAvaloniaDependencyResolver dependencyResolv
             _renderInterface = TryGetService<IPlatformRenderInterface>(dependencyResolver);
 
             var renderLoop = TryGetService<IRenderLoop>(dependencyResolver);
-            var rendererFactory = TryGetService<IRendererFactory>(dependencyResolver);
-            Renderer = rendererFactory?.CreateRenderer(this, renderLoop);
+            Renderer = impl.CreateRenderer(this);
 
             impl.SetInputRoot(this);
 
@@ -181,6 +180,9 @@ bool IInputRoot.ShowAccessKeys
         /// <inheritdoc/>
         double ILayoutRoot.LayoutScaling => PlatformImpl?.Scaling ?? 1;
 
+        /// <inheritdoc/>
+        double IRenderRoot.RenderScaling => PlatformImpl?.Scaling ?? 1;
+
         IStyleHost IStyleHost.StylingParent
         {
             get { return AvaloniaLocator.Current.GetService<IGlobalStyles>(); }
diff --git a/src/Avalonia.Controls/Window.cs b/src/Avalonia.Controls/Window.cs
index 3802f2b6eaf..46c625cc4cb 100644
--- a/src/Avalonia.Controls/Window.cs
+++ b/src/Avalonia.Controls/Window.cs
@@ -225,8 +225,14 @@ public void Close(object dialogResult)
         /// </summary>
         public override void Hide()
         {
+            if (!IsVisible)
+            {
+                return;
+            }
+
             using (BeginAutoSizing())
             {
+                Renderer?.Stop();
                 PlatformImpl?.Hide();
             }
 
@@ -252,6 +258,7 @@ public override void Show()
             using (BeginAutoSizing())
             {
                 PlatformImpl?.Show();
+                Renderer?.Start();
             }
         }
 
@@ -297,6 +304,8 @@ public Task<TResult> ShowDialog<TResult>()
                 var modal = PlatformImpl?.ShowDialog();
                 var result = new TaskCompletionSource<TResult>();
 
+                Renderer?.Start();
+
                 Observable.FromEventPattern<EventHandler, EventArgs>(
                     x => this.Closed += x,
                     x => this.Closed -= x)
diff --git a/src/Avalonia.Controls/WindowBase.cs b/src/Avalonia.Controls/WindowBase.cs
index fbdf64b14af..bcc09936ba1 100644
--- a/src/Avalonia.Controls/WindowBase.cs
+++ b/src/Avalonia.Controls/WindowBase.cs
@@ -117,6 +117,7 @@ public virtual void Hide()
 
             try
             {
+                Renderer?.Stop();
                 PlatformImpl?.Hide();
                 IsVisible = false;
             }
@@ -145,6 +146,7 @@ public virtual void Show()
                 }
 
                 PlatformImpl?.Show();
+                Renderer?.Start();
             }
             finally
             {
diff --git a/src/Avalonia.Themes.Default/CheckBox.xaml b/src/Avalonia.Themes.Default/CheckBox.xaml
index e88e93eac68..2fc19b2679c 100644
--- a/src/Avalonia.Themes.Default/CheckBox.xaml
+++ b/src/Avalonia.Themes.Default/CheckBox.xaml
@@ -1,10 +1,11 @@
 <Styles xmlns="https://github.com/avaloniaui">
   <Style Selector="CheckBox">
+    <Setter Property="Background" Value="Transparent"/>
     <Setter Property="BorderBrush" Value="{StyleResource ThemeBorderMidBrush}"/>
     <Setter Property="BorderThickness" Value="{StyleResource ThemeBorderThickness}"/>
     <Setter Property="Template">
       <ControlTemplate>
-        <Grid ColumnDefinitions="Auto,*">
+        <Grid ColumnDefinitions="Auto,*" Background="{TemplateBinding Background}">
           <Border Name="border"
                   BorderBrush="{TemplateBinding BorderBrush}"
                   BorderThickness="{TemplateBinding BorderThickness}"
diff --git a/src/Avalonia.Themes.Default/DropDownItem.xaml b/src/Avalonia.Themes.Default/DropDownItem.xaml
index 98e51a674f6..48d791f6292 100644
--- a/src/Avalonia.Themes.Default/DropDownItem.xaml
+++ b/src/Avalonia.Themes.Default/DropDownItem.xaml
@@ -1,5 +1,6 @@
 <Styles xmlns="https://github.com/avaloniaui">
   <Style Selector="DropDownItem">
+    <Setter Property="Background" Value="Transparent"/>
     <Setter Property="Padding" Value="2"/>
     <Setter Property="HorizontalAlignment" Value="Stretch"/>
     <Setter Property="HorizontalContentAlignment" Value="Left"/>
diff --git a/src/Avalonia.Themes.Default/ListBox.xaml b/src/Avalonia.Themes.Default/ListBox.xaml
index eecca023848..5aa23f52755 100644
--- a/src/Avalonia.Themes.Default/ListBox.xaml
+++ b/src/Avalonia.Themes.Default/ListBox.xaml
@@ -1,13 +1,13 @@
 <Style xmlns="https://github.com/avaloniaui" Selector="ListBox">
+  <Setter Property="Background" Value="{StyleResource ThemeBackgroundBrush}"/>
   <Setter Property="BorderBrush" Value="{StyleResource ThemeBorderMidBrush}"/>
   <Setter Property="BorderThickness" Value="{StyleResource ThemeBorderThickness}"/>
   <Setter Property="Padding" Value="4"/>
   <Setter Property="Template">
     <ControlTemplate>
-      <Border Background="{TemplateBinding Background}"
-              BorderBrush="{TemplateBinding BorderBrush}"
+      <Border BorderBrush="{TemplateBinding BorderBrush}"
               BorderThickness="{TemplateBinding BorderThickness}">
-        <ScrollViewer Name="PART_ScrollViewer">
+        <ScrollViewer Name="PART_ScrollViewer" Background="{TemplateBinding Background}">
           <ItemsPresenter Name="PART_ItemsPresenter"
                           Items="{TemplateBinding Items}"
                           ItemsPanel="{TemplateBinding ItemsPanel}"
diff --git a/src/Avalonia.Themes.Default/ListBoxItem.xaml b/src/Avalonia.Themes.Default/ListBoxItem.xaml
index 61466abd1bb..64fc62ba735 100644
--- a/src/Avalonia.Themes.Default/ListBoxItem.xaml
+++ b/src/Avalonia.Themes.Default/ListBoxItem.xaml
@@ -1,5 +1,6 @@
 <Styles xmlns="https://github.com/avaloniaui">
   <Style Selector="ListBoxItem">
+    <Setter Property="Background" Value="Transparent"/>
     <Setter Property="Template">
       <ControlTemplate>
         <ContentPresenter Name="PART_ContentPresenter"
diff --git a/src/Avalonia.Themes.Default/MenuItem.xaml b/src/Avalonia.Themes.Default/MenuItem.xaml
index a7af6c51cfc..6c5004c0c69 100644
--- a/src/Avalonia.Themes.Default/MenuItem.xaml
+++ b/src/Avalonia.Themes.Default/MenuItem.xaml
@@ -2,6 +2,7 @@
         xmlns:sys="clr-namespace:System;assembly=mscorlib">
   
   <Style Selector="MenuItem">
+    <Setter Property="Background" Value="Transparent"/>
     <Setter Property="BorderThickness" Value="1"/>
     <Setter Property="Padding" Value="6,0"/>
     <Setter Property="Template">
diff --git a/src/Avalonia.Themes.Default/RadioButton.xaml b/src/Avalonia.Themes.Default/RadioButton.xaml
index 182c710b7cc..7af8e0ff274 100644
--- a/src/Avalonia.Themes.Default/RadioButton.xaml
+++ b/src/Avalonia.Themes.Default/RadioButton.xaml
@@ -1,10 +1,11 @@
 <Styles xmlns="https://github.com/avaloniaui">
   <Style Selector="RadioButton">
+    <Setter Property="Background" Value="Transparent"/>
     <Setter Property="BorderBrush" Value="{StyleResource ThemeBorderMidBrush}"/>
     <Setter Property="BorderThickness" Value="{StyleResource ThemeBorderThickness}"/>
     <Setter Property="Template">
       <ControlTemplate>
-        <Grid ColumnDefinitions="Auto,*">
+        <Grid ColumnDefinitions="Auto,*" Background="{TemplateBinding Background}">
           <Ellipse Name="border"
                    Stroke="{TemplateBinding BorderBrush}"
                    StrokeThickness="{TemplateBinding BorderThickness}"
diff --git a/src/Avalonia.Themes.Default/ScrollViewer.xaml b/src/Avalonia.Themes.Default/ScrollViewer.xaml
index 3e211f460c5..4adfdaae2d0 100644
--- a/src/Avalonia.Themes.Default/ScrollViewer.xaml
+++ b/src/Avalonia.Themes.Default/ScrollViewer.xaml
@@ -1,8 +1,9 @@
 <Style xmlns="https://github.com/avaloniaui" Selector="ScrollViewer">
   <Setter Property="Template">
     <ControlTemplate>
-      <Grid ColumnDefinitions="*,Auto" RowDefinitions="*,Auto" Background="{TemplateBinding Background}">
+      <Grid ColumnDefinitions="*,Auto" RowDefinitions="*,Auto">
         <ScrollContentPresenter Name="PART_ContentPresenter"
+                                Background="{TemplateBinding Background}"
                                 Content="{TemplateBinding Content}"
                                 Extent="{TemplateBinding Path=Extent, Mode=TwoWay}"
                                 Margin="{TemplateBinding Padding}"
diff --git a/src/Avalonia.Themes.Default/TabStripItem.xaml b/src/Avalonia.Themes.Default/TabStripItem.xaml
index 35848bda592..cee1c5e4601 100644
--- a/src/Avalonia.Themes.Default/TabStripItem.xaml
+++ b/src/Avalonia.Themes.Default/TabStripItem.xaml
@@ -1,5 +1,6 @@
 <Styles xmlns="https://github.com/avaloniaui">
   <Style Selector="TabStripItem">
+    <Setter Property="Background" Value="Transparent"/>
     <Setter Property="FontSize" Value="{StyleResource FontSizeLarge}"/>
     <Setter Property="Foreground" Value="{StyleResource ThemeForegroundLightBrush}"/>
     <Setter Property="Template">
diff --git a/src/Avalonia.Themes.Default/TreeView.xaml b/src/Avalonia.Themes.Default/TreeView.xaml
index c8c22fe2993..838e007fb1c 100644
--- a/src/Avalonia.Themes.Default/TreeView.xaml
+++ b/src/Avalonia.Themes.Default/TreeView.xaml
@@ -1,13 +1,13 @@
 <Style xmlns="https://github.com/avaloniaui" Selector="TreeView">
+  <Setter Property="Background" Value="Transparent"/>
   <Setter Property="BorderBrush" Value="{StyleResource ThemeBorderMidBrush}"/>
   <Setter Property="BorderThickness" Value="{StyleResource ThemeBorderThickness}"/>
   <Setter Property="Padding" Value="4"/>
   <Setter Property="Template">
     <ControlTemplate>
-      <Border Background="{TemplateBinding Background}"
-              BorderBrush="{TemplateBinding BorderBrush}"
+      <Border BorderBrush="{TemplateBinding BorderBrush}"
               BorderThickness="{TemplateBinding BorderThickness}">
-        <ScrollViewer CanScrollHorizontally="True">
+        <ScrollViewer CanScrollHorizontally="True" Background="{TemplateBinding Background}">
           <ItemsPresenter Name="PART_ItemsPresenter"
                           Items="{TemplateBinding Items}"
                           ItemsPanel="{TemplateBinding ItemsPanel}"
diff --git a/src/Avalonia.Themes.Default/TreeViewItem.xaml b/src/Avalonia.Themes.Default/TreeViewItem.xaml
index 54aebb29515..1814b11bf0b 100644
--- a/src/Avalonia.Themes.Default/TreeViewItem.xaml
+++ b/src/Avalonia.Themes.Default/TreeViewItem.xaml
@@ -31,7 +31,8 @@
   <Style Selector="TreeViewItem /template/ ToggleButton#expander">
     <Setter Property="Template">
       <ControlTemplate>
-        <Border Width="14"
+        <Border Background="Transparent"
+                Width="14"
                 Height="12"
                 HorizontalAlignment="Center"
                 VerticalAlignment="Center">
diff --git a/src/Avalonia.Visuals/Media/BrushExtensions.cs b/src/Avalonia.Visuals/Media/BrushExtensions.cs
new file mode 100644
index 00000000000..cd351071dd3
--- /dev/null
+++ b/src/Avalonia.Visuals/Media/BrushExtensions.cs
@@ -0,0 +1,51 @@
+using System;
+
+namespace Avalonia.Media
+{
+    /// <summary>
+    /// Extension methods for brush classes.
+    /// </summary>
+    public static class BrushExtensions
+    {
+        /// <summary>
+        /// Converts a brush to an immutable brush.
+        /// </summary>
+        /// <param name="brush">The brush.</param>
+        /// <returns>
+        /// The result of calling <see cref="IMutableBrush.ToImmutable"/> if the brush is mutable,
+        /// otherwise <paramref name="brush"/>.
+        /// </returns>
+        public static IBrush ToImmutable(this IBrush brush)
+        {
+            Contract.Requires<ArgumentNullException>(brush != null);
+
+            return (brush as IMutableBrush)?.ToImmutable() ?? brush;
+        }
+
+        /// <summary>
+        /// Converts a pen to a pen with an immutable brush
+        /// </summary>
+        /// <param name="pen">The pen.</param>
+        /// <returns>
+        /// A copy of the pen with an immutable brush, or <paramref name="pen"/> if the pen's brush
+        /// is already immutable or null.
+        /// </returns>
+        public static Pen ToImmutable(this Pen pen)
+        {
+            Contract.Requires<ArgumentNullException>(pen != null);
+
+            var brush = pen?.Brush?.ToImmutable();
+            return pen == null || ReferenceEquals(pen?.Brush, brush) ?
+                pen :
+                new Pen(
+                    brush,
+                    thickness: pen.Thickness,
+                    dashStyle: pen.DashStyle,
+                    dashCap: pen.DashCap,
+                    startLineCap: pen.StartLineCap,
+                    endLineCap: pen.EndLineCap,
+                    lineJoin: pen.LineJoin,
+                    miterLimit: pen.MiterLimit);
+        }
+    }
+}
diff --git a/src/Avalonia.Visuals/Media/Imaging/IImageBrush.cs b/src/Avalonia.Visuals/Media/IImageBrush.cs
similarity index 100%
rename from src/Avalonia.Visuals/Media/Imaging/IImageBrush.cs
rename to src/Avalonia.Visuals/Media/IImageBrush.cs
diff --git a/src/Avalonia.Visuals/Platform/IDrawingContextImpl.cs b/src/Avalonia.Visuals/Platform/IDrawingContextImpl.cs
index 5c4eb01771c..14aef8463af 100644
--- a/src/Avalonia.Visuals/Platform/IDrawingContextImpl.cs
+++ b/src/Avalonia.Visuals/Platform/IDrawingContextImpl.cs
@@ -3,7 +3,6 @@
 
 using System;
 using Avalonia.Media;
-using Avalonia.Platform;
 
 namespace Avalonia.Platform
 {
@@ -32,6 +31,15 @@ public interface IDrawingContextImpl : IDisposable
         /// <param name="destRect">The rect in the output to draw to.</param>
         void DrawImage(IBitmapImpl source, double opacity, Rect sourceRect, Rect destRect);
 
+        /// <summary>
+        /// Draws a bitmap image.
+        /// </summary>
+        /// <param name="source">The bitmap image.</param>
+        /// <param name="opacityMask">The opacity mask to draw with.</param>
+        /// <param name="opacityMaskRect">The destination rect for the opacity mask.</param>
+        /// <param name="destRect">The rect in the output to draw to.</param>
+        void DrawImage(IBitmapImpl source, IBrush opacityMask, Rect opacityMaskRect, Rect destRect);
+
         /// <summary>
         /// Draws a line.
         /// </summary>
@@ -100,4 +108,4 @@ public interface IDrawingContextImpl : IDisposable
 
         void PopGeometryClip();
     }
-}
\ No newline at end of file
+}
diff --git a/src/Avalonia.Visuals/Properties/AssemblyInfo.cs b/src/Avalonia.Visuals/Properties/AssemblyInfo.cs
index 786ac3b0953..ded650e2ed4 100644
--- a/src/Avalonia.Visuals/Properties/AssemblyInfo.cs
+++ b/src/Avalonia.Visuals/Properties/AssemblyInfo.cs
@@ -2,8 +2,14 @@
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
 using System.Reflection;
+using System.Runtime.CompilerServices;
 using Avalonia.Metadata;
 
 [assembly: AssemblyTitle("Avalonia.Visuals")]
+[assembly: InternalsVisibleTo("Avalonia.Visuals.UnitTests")]
 [assembly: XmlnsDefinition("https://github.com/avaloniaui", "Avalonia.Animation")]
-[assembly: XmlnsDefinition("https://github.com/avaloniaui", "Avalonia.Media")]
\ No newline at end of file
+[assembly: XmlnsDefinition("https://github.com/avaloniaui", "Avalonia.Media")]
+
+[assembly: InternalsVisibleTo("Avalonia.Cairo.RenderTests")]
+[assembly: InternalsVisibleTo("Avalonia.Direct2D1.RenderTests")]
+[assembly: InternalsVisibleTo("Avalonia.Skia.RenderTests")]
\ No newline at end of file
diff --git a/src/Avalonia.Visuals/Rendering/DefaultRenderLayerFactory.cs b/src/Avalonia.Visuals/Rendering/DefaultRenderLayerFactory.cs
new file mode 100644
index 00000000000..c75f948b667
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/DefaultRenderLayerFactory.cs
@@ -0,0 +1,34 @@
+using System;
+using Avalonia.Platform;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Rendering
+{
+    public class DefaultRenderLayerFactory : IRenderLayerFactory
+    {
+        private IPlatformRenderInterface _renderInterface;
+
+        public DefaultRenderLayerFactory()
+            : this(AvaloniaLocator.Current.GetService<IPlatformRenderInterface>())
+        {
+        }
+
+        public DefaultRenderLayerFactory(IPlatformRenderInterface renderInterface)
+        {
+            _renderInterface = renderInterface;
+        }
+
+        public IRenderTargetBitmapImpl CreateLayer(
+            IVisual layerRoot,
+            Size size,
+            double dpiX,
+            double dpiY)
+        {
+            return _renderInterface.CreateRenderTargetBitmap(
+                (int)Math.Ceiling(size.Width),
+                (int)Math.Ceiling(size.Height),
+                dpiX,
+                dpiY);
+        }
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/DeferredRenderer.cs b/src/Avalonia.Visuals/Rendering/DeferredRenderer.cs
new file mode 100644
index 00000000000..9124f24d61e
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/DeferredRenderer.cs
@@ -0,0 +1,430 @@
+// Copyright (c) The Avalonia Project. All rights reserved.
+// Licensed under the MIT license. See licence.md file in the project root for full license information.
+
+using System;
+using Avalonia.Media;
+using Avalonia.Platform;
+using Avalonia.Rendering.SceneGraph;
+using Avalonia.Threading;
+using Avalonia.VisualTree;
+using System.Collections.Generic;
+using System.IO;
+using Avalonia.Media.Immutable;
+using System.Threading;
+
+namespace Avalonia.Rendering
+{
+    /// <summary>
+    /// A renderer which renders the state of the visual tree to an intermediate scene graph
+    /// representation which is then rendered on a rendering thread.
+    /// </summary>
+    public class DeferredRenderer : RendererBase, IRenderer, IVisualBrushRenderer
+    {
+        private readonly IDispatcher _dispatcher;
+        private readonly IRenderLoop _renderLoop;
+        private readonly IVisual _root;
+        private readonly ISceneBuilder _sceneBuilder;
+        private readonly RenderLayers _layers;
+        private readonly IRenderLayerFactory _layerFactory;
+
+        private bool _running;
+        private Scene _scene;
+        private IRenderTarget _renderTarget;
+        private DirtyVisuals _dirty;
+        private IRenderTargetBitmapImpl _overlay;
+        private bool _updateQueued;
+        private object _rendering = new object();
+        private int _lastSceneId = -1;
+        private DisplayDirtyRects _dirtyRectsDisplay = new DisplayDirtyRects();
+        private IDrawOperation _currentDraw;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DeferredRenderer"/> class.
+        /// </summary>
+        /// <param name="root">The control to render.</param>
+        /// <param name="renderLoop">The render loop.</param>
+        /// <param name="sceneBuilder">The scene builder to use. Optional.</param>
+        /// <param name="layerFactory">The layer factory to use. Optional.</param>
+        /// <param name="dispatcher">The dispatcher to use. Optional.</param>
+        public DeferredRenderer(
+            IRenderRoot root,
+            IRenderLoop renderLoop,
+            ISceneBuilder sceneBuilder = null,
+            IRenderLayerFactory layerFactory = null,
+            IDispatcher dispatcher = null)
+        {
+            Contract.Requires<ArgumentNullException>(root != null);
+
+            _dispatcher = dispatcher ?? Dispatcher.UIThread;
+            _root = root;
+            _sceneBuilder = sceneBuilder ?? new SceneBuilder();
+            _scene = new Scene(root);
+            _layerFactory = layerFactory ?? new DefaultRenderLayerFactory();
+            _layers = new RenderLayers(_layerFactory);
+            _renderLoop = renderLoop;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DeferredRenderer"/> class.
+        /// </summary>
+        /// <param name="root">The control to render.</param>
+        /// <param name="renderTarget">The render target.</param>
+        /// <param name="sceneBuilder">The scene builder to use. Optional.</param>
+        /// <param name="layerFactory">The layer factory to use. Optional.</param>
+        /// <remarks>
+        /// This constructor is intended to be used for unit testing.
+        /// </remarks>
+        public DeferredRenderer(
+            IVisual root,
+            IRenderTarget renderTarget,
+            ISceneBuilder sceneBuilder = null,
+            IRenderLayerFactory layerFactory = null)
+        {
+            Contract.Requires<ArgumentNullException>(root != null);
+            Contract.Requires<ArgumentNullException>(renderTarget != null);
+
+            _root = root;
+            _renderTarget = renderTarget;
+            _sceneBuilder = sceneBuilder ?? new SceneBuilder();
+            _scene = new Scene(root);
+            _layerFactory = layerFactory ?? new DefaultRenderLayerFactory();
+            _layers = new RenderLayers(_layerFactory);
+        }
+
+        /// <inheritdoc/>
+        public bool DrawFps { get; set; }
+
+        /// <inheritdoc/>
+        public bool DrawDirtyRects { get; set; }
+
+        /// <summary>
+        /// Gets or sets a path to which rendered frame should be rendered for debugging.
+        /// </summary>
+        public string DebugFramesPath { get; set; }
+
+        /// <inheritdoc/>
+        public void AddDirty(IVisual visual)
+        {
+            _dirty?.Add(visual);
+        }
+
+        /// <summary>
+        /// Disposes of the renderer and detaches from the render loop.
+        /// </summary>
+        public void Dispose() => Stop();
+
+        /// <inheritdoc/>
+        public IEnumerable<IVisual> HitTest(Point p, Func<IVisual, bool> filter)
+        {
+            if (_renderLoop == null && (_dirty == null || _dirty.Count > 0))
+            {
+                // When unit testing the renderLoop may be null, so update the scene manually.
+                UpdateScene();
+            }
+
+            return _scene.HitTest(p, filter);
+        }
+
+        /// <inheritdoc/>
+        public void Paint(Rect rect)
+        {
+        }
+
+        /// <inheritdoc/>
+        public void Resized(Size size)
+        {
+        }
+
+        /// <inheritdoc/>
+        public void Start()
+        {
+            if (!_running && _renderLoop != null)
+            {
+                _renderLoop.Tick += OnRenderLoopTick;
+                _running = true;
+            }
+        }
+
+        /// <inheritdoc/>
+        public void Stop()
+        {
+            if (_running && _renderLoop != null)
+            {
+                _renderLoop.Tick -= OnRenderLoopTick;
+                _running = false;
+            }
+        }
+
+        /// <inheritdoc/>
+        Size IVisualBrushRenderer.GetRenderTargetSize(IVisualBrush brush)
+        {
+            return (_currentDraw as BrushDrawOperation)?.ChildScenes?[brush.Visual]?.Size ?? Size.Empty;
+        }
+
+        /// <inheritdoc/>
+        void IVisualBrushRenderer.RenderVisualBrush(IDrawingContextImpl context, IVisualBrush brush)
+        {
+            var childScene = (_currentDraw as BrushDrawOperation)?.ChildScenes?[brush.Visual];
+
+            if (childScene != null)
+            {
+                Render(context, (VisualNode)childScene.Root, null, new Rect(childScene.Size));
+            }
+        }
+
+        internal void UnitTestUpdateScene() => UpdateScene();
+
+        internal void UnitTestRender() => Render(_scene);
+
+        private void Render(Scene scene)
+        {
+            _dirtyRectsDisplay.Tick();
+
+            if (scene.Size != Size.Empty)
+            {
+                if (scene.Generation != _lastSceneId)
+                {
+                    _layers.Update(scene);
+                    RenderToLayers(scene);
+
+                    if (DebugFramesPath != null)
+                    {
+                        SaveDebugFrames(scene.Generation);
+                    }
+
+                    _lastSceneId = scene.Generation;
+                }
+
+                RenderOverlay(scene);
+                RenderComposite(scene);
+            }
+        }
+
+        private void Render(IDrawingContextImpl context, VisualNode node, IVisual layer, Rect clipBounds)
+        {
+            if (layer == null || node.LayerRoot == layer)
+            {
+                clipBounds = node.ClipBounds.Intersect(clipBounds);
+
+                if (!clipBounds.IsEmpty)
+                {
+                    node.BeginRender(context);
+
+                    foreach (var operation in node.DrawOperations)
+                    {
+                        _currentDraw = operation;
+                        operation.Render(context);
+                        _currentDraw = null;
+                    }
+
+                    foreach (var child in node.Children)
+                    {
+                        Render(context, (VisualNode)child, layer, clipBounds);
+                    }
+
+                    node.EndRender(context);
+                }
+            }
+        }
+
+        private void RenderToLayers(Scene scene)
+        {
+            if (scene.Layers.HasDirty)
+            {
+                foreach (var layer in scene.Layers)
+                {
+                    var renderTarget = _layers[layer.LayerRoot].Bitmap;
+                    var node = (VisualNode)scene.FindNode(layer.LayerRoot);
+
+                    if (node != null)
+                    {
+                        using (var context = renderTarget.CreateDrawingContext(this))
+                        {
+                            foreach (var rect in layer.Dirty)
+                            {
+                                context.Transform = Matrix.Identity;
+                                context.PushClip(rect);
+                                context.Clear(Colors.Transparent);
+                                Render(context, node, layer.LayerRoot, rect);
+                                context.PopClip();
+
+                                if (DrawDirtyRects)
+                                {
+                                    _dirtyRectsDisplay.Add(rect);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        private void RenderOverlay(Scene scene)
+        {
+            if (DrawDirtyRects)
+            {
+                var overlay = GetOverlay(scene.Size, scene.Scaling);
+
+                using (var context = overlay.CreateDrawingContext(this))
+                {
+                    context.Clear(Colors.Transparent);
+                    RenderDirtyRects(context);
+                }
+            }
+            else
+            {
+                _overlay?.Dispose();
+                _overlay = null;
+            }
+        }
+
+        private void RenderDirtyRects(IDrawingContextImpl context)
+        {
+            foreach (var r in _dirtyRectsDisplay)
+            {
+                var brush = new ImmutableSolidColorBrush(Colors.Magenta, r.Opacity);
+                context.FillRectangle(brush, r.Rect);
+            }
+        }
+
+        private void RenderComposite(Scene scene)
+        {
+            try
+            {
+                if (_renderTarget == null)
+                {
+                    _renderTarget = ((IRenderRoot)_root).CreateRenderTarget();
+                }
+
+                using (var context = _renderTarget.CreateDrawingContext(this))
+                {
+                    var clientRect = new Rect(scene.Size);
+
+                    foreach (var layer in scene.Layers)
+                    {
+                        var bitmap = _layers[layer.LayerRoot].Bitmap;
+                        var sourceRect = new Rect(0, 0, bitmap.PixelWidth, bitmap.PixelHeight);
+
+                        if (layer.GeometryClip != null)
+                        {
+                            context.PushGeometryClip(layer.GeometryClip);
+                        }
+
+                        if (layer.OpacityMask == null)
+                        {
+                            context.DrawImage(bitmap, layer.Opacity, sourceRect, clientRect);
+                        }
+                        else
+                        {
+                            context.DrawImage(bitmap, layer.OpacityMask, layer.OpacityMaskRect, sourceRect);
+                        }
+
+                        if (layer.GeometryClip != null)
+                        {
+                            context.PopGeometryClip();
+                        }
+                    }
+
+                    if (_overlay != null)
+                    {
+                        var sourceRect = new Rect(0, 0, _overlay.PixelWidth, _overlay.PixelHeight);
+                        context.DrawImage(_overlay, 0.5, sourceRect, clientRect);
+                    }
+
+                    if (DrawFps)
+                    {
+                        RenderFps(context, clientRect, true);
+                    }
+                }
+            }
+            catch (RenderTargetCorruptedException ex)
+            {
+                Logging.Logger.Information("Renderer", this, "Render target was corrupted. Exception: {0}", ex);
+                _renderTarget?.Dispose();
+                _renderTarget = null;
+            }
+        }
+
+        private void UpdateScene()
+        {
+            Dispatcher.UIThread.VerifyAccess();
+
+            try
+            {
+                var scene = _scene.Clone();
+
+                if (_dirty == null)
+                {
+                    _dirty = new DirtyVisuals();
+                    _sceneBuilder.UpdateAll(scene);
+                }
+                else if (_dirty.Count > 0)
+                {
+                    foreach (var visual in _dirty)
+                    {
+                        _sceneBuilder.Update(scene, visual);
+                    }
+                }
+
+                Interlocked.Exchange(ref _scene, scene);
+
+                _dirty.Clear();
+                (_root as IRenderRoot)?.Invalidate(new Rect(scene.Size));
+            }
+            finally
+            {
+                _updateQueued = false;
+            }
+        }
+
+        private void OnRenderLoopTick(object sender, EventArgs e)
+        {
+            if (Monitor.TryEnter(_rendering))
+            {
+                try
+                {
+                    if (!_updateQueued && (_dirty == null || _dirty.Count > 0))
+                    {
+                        _updateQueued = true;
+                        _dispatcher.InvokeAsync(UpdateScene, DispatcherPriority.Render);
+                    }
+
+                    Scene scene = null;
+                    Interlocked.Exchange(ref scene, _scene);
+                    Render(scene);
+                }
+                catch { }
+                finally
+                {
+                    Monitor.Exit(_rendering);
+                }
+            }
+        }
+
+        private IRenderTargetBitmapImpl GetOverlay(Size size, double scaling)
+        {
+            size = new Size(size.Width * scaling, size.Height * scaling);
+
+            if (_overlay == null ||
+                _overlay.PixelWidth != size.Width ||
+                _overlay.PixelHeight != size.Height)
+            {
+                _overlay?.Dispose();
+                _overlay = _layerFactory.CreateLayer(null, size, 96 * scaling, 96 * scaling);
+            }
+
+            return _overlay;
+        }
+
+        private void SaveDebugFrames(int id)
+        {
+            var index = 0;
+
+            foreach (var layer in _layers)
+            {
+                var fileName = Path.Combine(DebugFramesPath, $"frame-{id}-layer-{index++}.png");
+                layer.Bitmap.Save(fileName);
+            }
+        }
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/DirtyRects.cs b/src/Avalonia.Visuals/Rendering/DirtyRects.cs
new file mode 100644
index 00000000000..473d002c766
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/DirtyRects.cs
@@ -0,0 +1,88 @@
+// Copyright (c) The Avalonia Project. All rights reserved.
+// Licensed under the MIT license. See licence.md file in the project root for full license information.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Avalonia.Rendering
+{
+    /// <summary>
+    /// Tracks dirty rectangles.
+    /// </summary>
+    internal class DirtyRects : IEnumerable<Rect>
+    {
+        private List<Rect> _rects = new List<Rect>();
+
+        public bool IsEmpty => _rects.Count == 0;
+
+        /// <summary>
+        /// Adds a dirty rectangle, extending an existing dirty rectangle if it intersects.
+        /// </summary>
+        /// <param name="rect">The dirt rectangle.</param>
+        /// <remarks>
+        /// We probably want to do this more intellegently because:
+        /// - Adding e.g. the top left quarter of a scene and the bottom left quarter of a scene
+        ///   will cause the whole scene to be invalidated if they overlap by a single pixel
+        /// - Adding two adjacent rectangles that don't overlap will not cause them to be 
+        /// coalesced
+        /// - It only coaleces the first intersecting rectangle found - one needs to
+        ///  call <see cref="Coalesce"/> at the end of the draw cycle to coalesce the rest.
+        /// </remarks>
+        public void Add(Rect rect)
+        {
+            if (!rect.IsEmpty)
+            {
+                for (var i = 0; i < _rects.Count; ++i)
+                {
+                    var r = _rects[i];
+
+                    if (r.Intersects(rect))
+                    {
+                        _rects[i] = r.Union(rect);
+                        return;
+                    }
+                }
+
+                _rects.Add(rect);
+            }
+        }
+
+        /// <summary>
+        /// Works around our flimsy dirt-rect coalescing algorithm.
+        /// </summary>
+        /// <remarks>
+        /// See the comments in <see cref="Add(Rect)"/>.
+        /// </remarks>
+        public void Coalesce()
+        {
+            for (var i = _rects.Count - 1; i >= 0; --i)
+            {
+                var a = _rects[i];
+
+                for (var j = 0; j < i; ++j)
+                {
+                    var b = _rects[j];
+
+                    if (i < _rects.Count && a.Intersects(b))
+                    {
+                        _rects[i] = _rects[i].Union(b);
+                        _rects.RemoveAt(i);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets the dirty rectangles.
+        /// </summary>
+        /// <returns>A collection of dirty rectangles</returns>
+        public IEnumerator<Rect> GetEnumerator() => _rects.GetEnumerator();
+
+        /// <summary>
+        /// Gets the dirty rectangles.
+        /// </summary>
+        /// <returns>A collection of dirty rectangles</returns>
+        IEnumerator IEnumerable.GetEnumerator() => _rects.GetEnumerator();
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/DirtyVisuals.cs b/src/Avalonia.Visuals/Rendering/DirtyVisuals.cs
new file mode 100644
index 00000000000..f14f5bc912d
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/DirtyVisuals.cs
@@ -0,0 +1,107 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Rendering
+{
+    /// <summary>
+    /// Stores a list of dirty visuals for an <see cref="IRenderer"/>.
+    /// </summary>
+    /// <remarks>
+    /// This class stores the dirty visuals for a scene, ordered by their distance to the root
+    /// visual. TODO: We probably want to put an upper limit on the number of visuals that can be
+    /// stored and if we reach that limit, assume all visuals are dirty.
+    /// </remarks>
+    internal class DirtyVisuals : IEnumerable<IVisual>
+    {
+        private SortedDictionary<int, List<IVisual>> _inner = new SortedDictionary<int, List<IVisual>>();
+        private Dictionary<IVisual, int> _index = new Dictionary<IVisual, int>();
+
+        /// <summary>
+        /// Gets the number of dirty visuals.
+        /// </summary>
+        public int Count => _index.Count;
+
+        /// <summary>
+        /// Adds a visual to the dirty list.
+        /// </summary>
+        /// <param name="visual">The dirty visual.</param>
+        public void Add(IVisual visual)
+        {
+            var distance = visual.CalculateDistanceFromAncestor(visual.VisualRoot);
+            int existingDistance;
+
+            if (_index.TryGetValue(visual, out existingDistance))
+            {
+                if (distance == existingDistance)
+                {
+                    return;
+                }
+
+                _inner[existingDistance].Remove(visual);
+                _index.Remove(visual);
+            }
+
+            List<IVisual> list;
+
+            if (!_inner.TryGetValue(distance, out list))
+            {
+                list = new List<IVisual>();
+                _inner.Add(distance, list);
+            }
+
+            list.Add(visual);
+            _index.Add(visual, distance);
+        }
+
+        /// <summary>
+        /// Clears the list.
+        /// </summary>
+        public void Clear()
+        {
+            _inner.Clear();
+            _index.Clear();
+        }
+
+        /// <summary>
+        /// Removes a visual from the dirty list.
+        /// </summary>
+        /// <param name="visual">The visual.</param>
+        /// <returns>True if the visual was present in the list; otherwise false.</returns>
+        public bool Remove(IVisual visual)
+        {
+            int distance;
+
+            if (_index.TryGetValue(visual, out distance))
+            {
+                _inner[distance].Remove(visual);
+                _index.Remove(visual);
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Gets the dirty visuals, in ascending order of distance to their root.
+        /// </summary>
+        /// <returns>A collection of visuals.</returns>
+        public IEnumerator<IVisual> GetEnumerator()
+        {
+            foreach (var i in _inner)
+            {
+                foreach (var j in i.Value)
+                {
+                    yield return j;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets the dirty visuals, in ascending order of distance to their root.
+        /// </summary>
+        /// <returns>A collection of visuals.</returns>
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/DisplayDirtyRect.cs b/src/Avalonia.Visuals/Rendering/DisplayDirtyRect.cs
new file mode 100644
index 00000000000..03b8e958259
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/DisplayDirtyRect.cs
@@ -0,0 +1,51 @@
+using System;
+
+namespace Avalonia.Rendering
+{
+    /// <summary>
+    /// Holds the state for a dirty rect rendered when <see cref="IRenderer.DrawDirtyRects"/> is set.
+    /// </summary>
+    internal class DisplayDirtyRect
+    {
+        public static readonly TimeSpan TimeToLive = TimeSpan.FromMilliseconds(250);
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DisplayDirtyRect"/> class.
+        /// </summary>
+        /// <param name="rect">The dirt rect.</param>
+        public DisplayDirtyRect(Rect rect)
+        {
+            Rect = rect;
+            ResetLifetime();
+        }
+
+        /// <summary>
+        /// Gets the bounds of the dirty rectangle.
+        /// </summary>
+        public Rect Rect { get; }
+
+        /// <summary>
+        /// Gets the time at which the rectangle was made dirty.
+        /// </summary>
+        public DateTimeOffset Born { get; private set; }
+
+        /// <summary>
+        /// Gets the time at which the rectagle should no longer be displayed.
+        /// </summary>
+        public DateTimeOffset Dies { get; private set; }
+
+        /// <summary>
+        /// Gets the opacity at which to display the dirty rectangle.
+        /// </summary>
+        public double Opacity => (Dies - DateTimeOffset.UtcNow).TotalMilliseconds / TimeToLive.TotalMilliseconds;
+
+        /// <summary>
+        /// Resets the rectangle's lifetime.
+        /// </summary>
+        public void ResetLifetime()
+        {
+            Born = DateTimeOffset.UtcNow;
+            Dies = Born + TimeToLive;
+        }
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/DisplayDirtyRects.cs b/src/Avalonia.Visuals/Rendering/DisplayDirtyRects.cs
new file mode 100644
index 00000000000..2ffc1b4118d
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/DisplayDirtyRects.cs
@@ -0,0 +1,62 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Avalonia.Rendering
+{
+    /// <summary>
+    /// Holds a collection of <see cref="DisplayDirtyRect"/> objects and manages their aging.
+    /// </summary>
+    internal class DisplayDirtyRects : IEnumerable<DisplayDirtyRect>
+    {
+        private List<DisplayDirtyRect> _inner = new List<DisplayDirtyRect>();
+
+        /// <summary>
+        /// Adds new new dirty rect to the collection.
+        /// </summary>
+        /// <param name="rect"></param>
+        public void Add(Rect rect)
+        {
+            foreach (var r in _inner)
+            {
+                if (r.Rect == rect)
+                {
+                    r.ResetLifetime();
+                    return;
+                }
+            }
+
+            _inner.Add(new DisplayDirtyRect(rect));
+        }
+
+        /// <summary>
+        /// Removes dirty rects one they are no longer active.
+        /// </summary>
+        public void Tick()
+        {
+            var now = DateTimeOffset.UtcNow;
+
+            for (var i = _inner.Count - 1; i >= 0; --i)
+            {
+                var r = _inner[i];
+
+                if (now > r.Dies)
+                {
+                    _inner.RemoveAt(i);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets the dirty rects.
+        /// </summary>
+        /// <returns>A collection of <see cref="DisplayDirtyRect"/> objects.</returns>
+        public IEnumerator<DisplayDirtyRect> GetEnumerator() => _inner.GetEnumerator();
+
+        /// <summary>
+        /// Gets the dirty rects.
+        /// </summary>
+        /// <returns>A collection of <see cref="DisplayDirtyRect"/> objects.</returns>
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/IRenderLayerFactory.cs b/src/Avalonia.Visuals/Rendering/IRenderLayerFactory.cs
new file mode 100644
index 00000000000..ed2751cd64b
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/IRenderLayerFactory.cs
@@ -0,0 +1,11 @@
+using System;
+using Avalonia.Platform;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Rendering
+{
+    public interface IRenderLayerFactory
+    {
+        IRenderTargetBitmapImpl CreateLayer(IVisual layerRoot, Size size, double dpiX, double dpiY);
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/IRenderRoot.cs b/src/Avalonia.Visuals/Rendering/IRenderRoot.cs
index 50cda1b1b83..2982a5d0812 100644
--- a/src/Avalonia.Visuals/Rendering/IRenderRoot.cs
+++ b/src/Avalonia.Visuals/Rendering/IRenderRoot.cs
@@ -22,6 +22,11 @@ public interface IRenderRoot : IVisual
         /// </summary>
         IRenderer Renderer { get; }
 
+        /// <summary>
+        /// The scaling factor to use in rendering.
+        /// </summary>
+        double RenderScaling { get; }
+
         /// <summary>
         /// Creates a render target for the window.
         /// </summary>
diff --git a/src/Avalonia.Visuals/Rendering/IRenderer.cs b/src/Avalonia.Visuals/Rendering/IRenderer.cs
index 8d2fc3a0c16..aa2413bdfbb 100644
--- a/src/Avalonia.Visuals/Rendering/IRenderer.cs
+++ b/src/Avalonia.Visuals/Rendering/IRenderer.cs
@@ -48,5 +48,15 @@ public interface IRenderer : IDisposable
         /// </summary>
         /// <param name="rect">The dirty rectangle.</param>
         void Paint(Rect rect);
+
+        /// <summary>
+        /// Starts the renderer.
+        /// </summary>
+        void Start();
+
+        /// <summary>
+        /// Stops the renderer.
+        /// </summary>
+        void Stop();
     }
 }
\ No newline at end of file
diff --git a/src/Avalonia.Visuals/Rendering/IRendererFactory.cs b/src/Avalonia.Visuals/Rendering/IRendererFactory.cs
deleted file mode 100644
index 8e27f851934..00000000000
--- a/src/Avalonia.Visuals/Rendering/IRendererFactory.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-using System;
-
-namespace Avalonia.Rendering
-{
-    /// <summary>
-    /// Defines a factory for creating <see cref="IRenderer"/> instances.
-    /// </summary>
-    public interface IRendererFactory
-    {
-        /// <summary>
-        /// Creates a new renderer for the specified render root.
-        /// </summary>
-        /// <param name="root">The render root.</param>
-        /// <param name="renderLoop">The render loop.</param>
-        /// <returns>An instance of an <see cref="IRenderer"/>.</returns>
-        IRenderer CreateRenderer(IRenderRoot root, IRenderLoop renderLoop);
-    }
-}
diff --git a/src/Avalonia.Visuals/Rendering/ImmediateRenderer.cs b/src/Avalonia.Visuals/Rendering/ImmediateRenderer.cs
index 7d2222e4495..4ef2b304635 100644
--- a/src/Avalonia.Visuals/Rendering/ImmediateRenderer.cs
+++ b/src/Avalonia.Visuals/Rendering/ImmediateRenderer.cs
@@ -20,11 +20,6 @@ namespace Avalonia.Rendering
     /// </remarks>
     public class ImmediateRenderer : RendererBase, IRenderer, IVisualBrushRenderer
     {
-        class ImmediateRendererFactory : IRendererFactory
-        {
-            public IRenderer CreateRenderer(IRenderRoot root, IRenderLoop renderLoop) => new ImmediateRenderer(root);
-        }
-
         private readonly IVisual _root;
         private readonly IRenderRoot _renderRoot;
         private IRenderTarget _renderTarget;
@@ -41,8 +36,6 @@ public ImmediateRenderer(IVisual root)
             _renderRoot = root as IRenderRoot;
         }
 
-        public static IRendererFactory Factory { get; } = new ImmediateRendererFactory();
-
         /// <inheritdoc/>
         public bool DrawFps { get; set; }
 
@@ -148,6 +141,16 @@ public IEnumerable<IVisual> HitTest(Point p, Func<IVisual, bool> filter)
             return HitTest(_root, p, filter);
         }
 
+        /// <inheritdoc/>
+        public void Start()
+        {
+        }
+
+        /// <inheritdoc/>
+        public void Stop()
+        {
+        }
+
         /// <inheritdoc/>
         Size IVisualBrushRenderer.GetRenderTargetSize(IVisualBrush brush)
         {
diff --git a/src/Avalonia.Visuals/Rendering/RenderLayer.cs b/src/Avalonia.Visuals/Rendering/RenderLayer.cs
new file mode 100644
index 00000000000..df9497af6fd
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/RenderLayer.cs
@@ -0,0 +1,47 @@
+using System;
+using Avalonia.Media;
+using Avalonia.Platform;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Rendering
+{
+    public class RenderLayer
+    {
+        private readonly IRenderLayerFactory _factory;
+
+        public RenderLayer(
+            IRenderLayerFactory factory,
+            Size size,
+            double scaling,
+            IVisual layerRoot)
+        {
+            _factory = factory;
+            Bitmap = factory.CreateLayer(layerRoot, size * scaling, 96 * scaling, 96 * scaling);
+            Size = size;
+            Scaling = scaling;
+            LayerRoot = layerRoot;
+        }
+
+        public IRenderTargetBitmapImpl Bitmap { get; private set; }
+        public double Scaling { get; private set; }
+        public Size Size { get; private set; }
+        public IVisual LayerRoot { get; }
+
+        public void ResizeBitmap(Size size, double scaling)
+        {
+            if (Size != size || Scaling != scaling)
+            {
+                var resized = _factory.CreateLayer(LayerRoot, size * scaling, 96 * scaling, 96 * scaling);
+
+                using (var context = resized.CreateDrawingContext(null))
+                {
+                    context.Clear(Colors.Transparent);
+                    context.DrawImage(Bitmap, 1, new Rect(Size), new Rect(Size));
+                    Bitmap.Dispose();
+                    Bitmap = resized;
+                    Size = size;
+                }
+            }
+        }
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/RenderLayers.cs b/src/Avalonia.Visuals/Rendering/RenderLayers.cs
new file mode 100644
index 00000000000..e1b22c55e0b
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/RenderLayers.cs
@@ -0,0 +1,63 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Avalonia.Rendering.SceneGraph;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Rendering
+{
+    public class RenderLayers : IEnumerable<RenderLayer>
+    {
+        private readonly IRenderLayerFactory _factory;
+        private List<RenderLayer> _inner = new List<RenderLayer>();
+        private Dictionary<IVisual, RenderLayer> _index = new Dictionary<IVisual, RenderLayer>();
+
+        public RenderLayers(IRenderLayerFactory factory)
+        {
+            _factory = factory;
+        }
+
+        public int Count => _inner.Count;
+        public RenderLayer this[IVisual layerRoot] => _index[layerRoot];
+
+        public void Update(Scene scene)
+        {
+            for (var i = scene.Layers.Count - 1; i >= 0; --i)
+            {
+                var src = scene.Layers[i];
+                RenderLayer layer;
+
+                if (!_index.TryGetValue(src.LayerRoot, out layer))
+                {
+                    layer = new RenderLayer(_factory, scene.Size, scene.Scaling, src.LayerRoot);
+                    _inner.Add(layer);
+                    _index.Add(src.LayerRoot, layer);
+                }
+                else
+                {
+                    layer.ResizeBitmap(scene.Size, scene.Scaling);
+                }
+            }
+
+            for (var i = _inner.Count - 1; i >= 0; --i)
+            {
+                var layer = _inner[i];
+
+                if (!scene.Layers.Exists(layer.LayerRoot))
+                {
+                    layer.Bitmap.Dispose();
+                    _inner.RemoveAt(i);
+                    _index.Remove(layer.LayerRoot);
+                }
+            }
+        }
+
+        public bool TryGetValue(IVisual layerRoot, out RenderLayer value)
+        {
+            return _index.TryGetValue(layerRoot, out value);
+        }
+
+        public IEnumerator<RenderLayer> GetEnumerator() => _inner.GetEnumerator();
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/BrushDrawOperation.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/BrushDrawOperation.cs
new file mode 100644
index 00000000000..59a895a22ff
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/BrushDrawOperation.cs
@@ -0,0 +1,31 @@
+// Copyright (c) The Avalonia Project. All rights reserved.
+// Licensed under the MIT license. See licence.md file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using Avalonia.Media;
+using Avalonia.Platform;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Rendering.SceneGraph
+{
+    /// <summary>
+    /// Base class for draw operations that can use a brush.
+    /// </summary>
+    internal abstract class BrushDrawOperation : IDrawOperation
+    {
+        /// <inheritdoc/>
+        public abstract Rect Bounds { get; }
+
+        /// <inheritdoc/>
+        public abstract bool HitTest(Point p);
+
+        /// <summary>
+        /// Gets a collection of child scenes that are needed to draw visual brushes.
+        /// </summary>
+        public abstract IDictionary<IVisual, Scene> ChildScenes { get; }
+
+        /// <inheritdoc/>
+        public abstract void Render(IDrawingContextImpl context);
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/ClipNode.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/ClipNode.cs
new file mode 100644
index 00000000000..1cda1d54610
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/ClipNode.cs
@@ -0,0 +1,64 @@
+using System;
+using Avalonia.Platform;
+
+namespace Avalonia.Rendering.SceneGraph
+{
+    /// <summary>
+    /// A node in the scene graph which represents a clip push or pop.
+    /// </summary>
+    internal class ClipNode : IDrawOperation
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ClipNode"/> class that represents a
+        /// clip push.
+        /// </summary>
+        /// <param name="clip">The clip to push.</param>
+        public ClipNode(Rect clip)
+        {
+            Clip = clip;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ClipNode"/> class that represents a
+        /// clip pop.
+        /// </summary>
+        public ClipNode()
+        {
+        }
+
+        /// <inheritdoc/>
+        public Rect Bounds => Rect.Empty;
+
+        /// <summary>
+        /// Gets the clip to be pushed or null if the operation represents a pop.
+        /// </summary>
+        public Rect? Clip { get; }
+
+        /// <inheritdoc/>
+        public bool HitTest(Point p) => false;
+
+        /// <summary>
+        /// Determines if this draw operation equals another.
+        /// </summary>
+        /// <param name="clip">The clip of the other draw operation.</param>
+        /// <returns>True if the draw operations are the same, otherwise false.</returns>
+        /// <remarks>
+        /// The properties of the other draw operation are passed in as arguments to prevent
+        /// allocation of a not-yet-constructed draw operation object.
+        /// </remarks>
+        public bool Equals(Rect? clip) => Clip == clip;
+
+        /// <inheritdoc/>
+        public void Render(IDrawingContextImpl context)
+        {
+            if (Clip.HasValue)
+            {
+                context.PushClip(Clip.Value);
+            }
+            else
+            {
+                context.PopClip();
+            }
+        }
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/DeferredDrawingContextImpl.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/DeferredDrawingContextImpl.cs
new file mode 100644
index 00000000000..0b01960d5b6
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/DeferredDrawingContextImpl.cs
@@ -0,0 +1,392 @@
+// Copyright (c) The Avalonia Project. All rights reserved.
+// Licensed under the MIT license. See licence.md file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using Avalonia.Media;
+using Avalonia.Platform;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Rendering.SceneGraph
+{
+    /// <summary>
+    /// A drawing context which builds a scene graph.
+    /// </summary>
+    internal class DeferredDrawingContextImpl : IDrawingContextImpl
+    {
+        private readonly ISceneBuilder _sceneBuilder;
+        private VisualNode _node;
+        private int _childIndex;
+        private int _drawOperationindex;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DeferredDrawingContextImpl"/> class.
+        /// </summary>
+        /// <param name="sceneBuilder">
+        /// A scene builder used for constructing child scenes for visual brushes.
+        /// </param>
+        /// <param name="layers">The scene layers.</param>
+        public DeferredDrawingContextImpl(ISceneBuilder sceneBuilder, SceneLayers layers)
+        {
+            _sceneBuilder = sceneBuilder;
+            Layers = layers;
+        }
+
+        /// <inheritdoc/>
+        public Matrix Transform { get; set; } = Matrix.Identity;
+
+        /// <summary>
+        /// Gets the layers in the scene being built.
+        /// </summary>
+        public SceneLayers Layers { get; }
+
+        /// <summary>
+        /// Informs the drawing context of the visual node that is about to be rendered.
+        /// </summary>
+        /// <param name="node">The visual node.</param>
+        /// <returns>
+        /// An object which when disposed will commit the changes to visual node.
+        /// </returns>
+        public UpdateState BeginUpdate(VisualNode node)
+        {
+            Contract.Requires<ArgumentNullException>(node != null);
+
+            if (_node != null)
+            {
+                if (_childIndex < _node.Children.Count)
+                {
+                    _node.ReplaceChild(_childIndex, node);
+                }
+                else
+                {
+                    _node.AddChild(node);
+                }
+
+                ++_childIndex;
+            }
+
+            var state = new UpdateState(this, _node, _childIndex, _drawOperationindex);
+            _node = node;
+            _childIndex = _drawOperationindex = 0;
+            return state;
+        }
+
+        /// <inheritdoc/>
+        public void Clear(Color color)
+        {
+            // Cannot clear a deferred scene.
+        }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            // Nothing to do here as we allocate no unmanaged resources.
+        }
+
+        /// <summary>
+        /// Removes any remaining drawing operations from the visual node.
+        /// </summary>
+        /// <remarks>
+        /// Drawing operations are updated in place, overwriting existing drawing operations if
+        /// they are different. Once drawing has completed for the current visual node, it is
+        /// possible that there are stale drawing operations at the end of the list. This method
+        /// trims these stale drawing operations.
+        /// </remarks>
+        public void TrimChildren()
+        {
+            _node.TrimChildren(_childIndex);
+        }
+
+        /// <inheritdoc/>
+        public void DrawGeometry(IBrush brush, Pen pen, IGeometryImpl geometry)
+        {
+            var next = NextDrawAs<GeometryNode>();
+
+            if (next == null || !next.Equals(Transform, brush, pen, geometry))
+            {
+                Add(new GeometryNode(Transform, brush, pen, geometry, CreateChildScene(brush)));
+            }
+            else
+            {
+                ++_drawOperationindex;
+            }
+        }
+
+        /// <inheritdoc/>
+        public void DrawImage(IBitmapImpl source, double opacity, Rect sourceRect, Rect destRect)
+        {
+            var next = NextDrawAs<ImageNode>();
+
+            if (next == null || !next.Equals(Transform, source, opacity, sourceRect, destRect))
+            {
+                Add(new ImageNode(Transform, source, opacity, sourceRect, destRect));
+            }
+            else
+            {
+                ++_drawOperationindex;
+            }
+        }
+
+        /// <inheritdoc/>
+        public void DrawImage(IBitmapImpl source, IBrush opacityMask, Rect opacityMaskRect, Rect sourceRect)
+        {
+            // This method is currently only used to composite layers so shouldn't be called here.
+            throw new NotSupportedException();
+        }
+
+        /// <inheritdoc/>
+        public void DrawLine(Pen pen, Point p1, Point p2)
+        {
+            var next = NextDrawAs<LineNode>();
+
+            if (next == null || !next.Equals(Transform, pen, p1, p2))
+            {
+                Add(new LineNode(Transform, pen, p1, p2, CreateChildScene(pen.Brush)));
+            }
+            else
+            {
+                ++_drawOperationindex;
+            }
+        }
+
+        /// <inheritdoc/>
+        public void DrawRectangle(Pen pen, Rect rect, float cornerRadius = 0)
+        {
+            var next = NextDrawAs<RectangleNode>();
+
+            if (next == null || !next.Equals(Transform, null, pen, rect, cornerRadius))
+            {
+                Add(new RectangleNode(Transform, null, pen, rect, cornerRadius, CreateChildScene(pen.Brush)));
+            }
+            else
+            {
+                ++_drawOperationindex;
+            }
+        }
+
+        /// <inheritdoc/>
+        public void DrawText(IBrush foreground, Point origin, IFormattedTextImpl text)
+        {
+            var next = NextDrawAs<TextNode>();
+
+            if (next == null || !next.Equals(Transform, foreground, origin, text))
+            {
+                Add(new TextNode(Transform, foreground, origin, text, CreateChildScene(foreground)));
+            }
+            else
+            {
+                ++_drawOperationindex;
+            }
+        }
+
+        /// <inheritdoc/>
+        public void FillRectangle(IBrush brush, Rect rect, float cornerRadius = 0)
+        {
+            var next = NextDrawAs<RectangleNode>();
+
+            if (next == null || !next.Equals(Transform, brush, null, rect, cornerRadius))
+            {
+                Add(new RectangleNode(Transform, brush, null, rect, cornerRadius, CreateChildScene(brush)));
+            }
+            else
+            {
+                ++_drawOperationindex;
+            }
+        }
+
+        /// <inheritdoc/>
+        public void PopClip()
+        {
+            var next = NextDrawAs<ClipNode>();
+
+            if (next == null || !next.Equals(null))
+            {
+                Add(new ClipNode());
+            }
+            else
+            {
+                ++_drawOperationindex;
+            }
+        }
+
+        /// <inheritdoc/>
+        public void PopGeometryClip()
+        {
+            var next = NextDrawAs<GeometryClipNode>();
+
+            if (next == null || !next.Equals(null))
+            {
+                Add(new GeometryClipNode());
+            }
+            else
+            {
+                ++_drawOperationindex;
+            }
+        }
+
+        /// <inheritdoc/>
+        public void PopOpacity()
+        {
+            var next = NextDrawAs<OpacityNode>();
+
+            if (next == null || !next.Equals(null))
+            {
+                Add(new OpacityNode());
+            }
+            else
+            {
+                ++_drawOperationindex;
+            }
+        }
+
+        /// <inheritdoc/>
+        public void PopOpacityMask()
+        {
+            var next = NextDrawAs<OpacityMaskNode>();
+
+            if (next == null || !next.Equals(null, null))
+            {
+                Add(new OpacityMaskNode());
+            }
+            else
+            {
+                ++_drawOperationindex;
+            }
+        }
+
+        /// <inheritdoc/>
+        public void PushClip(Rect clip)
+        {
+            var next = NextDrawAs<ClipNode>();
+
+            if (next == null || !next.Equals(clip))
+            {
+                Add(new ClipNode(clip));
+            }
+            else
+            {
+                ++_drawOperationindex;
+            }
+        }
+
+        /// <inheritdoc/>
+        public void PushGeometryClip(IGeometryImpl clip)
+        {
+            var next = NextDrawAs<GeometryClipNode>();
+
+            if (next == null || !next.Equals(clip))
+            {
+                Add(new GeometryClipNode(clip));
+            }
+            else
+            {
+                ++_drawOperationindex;
+            }
+        }
+
+        /// <inheritdoc/>
+        public void PushOpacity(double opacity)
+        {
+            var next = NextDrawAs<OpacityNode>();
+
+            if (next == null || !next.Equals(opacity))
+            {
+                Add(new OpacityNode(opacity));
+            }
+            else
+            {
+                ++_drawOperationindex;
+            }
+        }
+
+        /// <inheritdoc/>
+        public void PushOpacityMask(IBrush mask, Rect bounds)
+        {
+            var next = NextDrawAs<OpacityMaskNode>();
+
+            if (next == null || !next.Equals(mask, bounds))
+            {
+                Add(new OpacityMaskNode(mask, bounds, CreateChildScene(mask)));
+            }
+            else
+            {
+                ++_drawOperationindex;
+            }
+        }
+
+        public struct UpdateState : IDisposable
+        {
+            public UpdateState(
+                DeferredDrawingContextImpl owner,
+                VisualNode node,
+                int childIndex,
+                int drawOperationIndex)
+            {
+                Owner = owner;
+                Node = node;
+                ChildIndex = childIndex;
+                DrawOperationIndex = drawOperationIndex;
+            }
+
+            public void Dispose()
+            {
+                Owner._node.TrimDrawOperations(Owner._drawOperationindex);
+
+                var dirty = Owner.Layers.GetOrAdd(Owner._node.LayerRoot).Dirty;
+
+                foreach (var operation in Owner._node.DrawOperations)
+                {
+                    dirty.Add(operation.Bounds);
+                }
+
+                Owner._node = Node;
+                Owner._childIndex = ChildIndex;
+                Owner._drawOperationindex = DrawOperationIndex;
+            }
+
+            public DeferredDrawingContextImpl Owner { get; }
+            public VisualNode Node { get; }
+            public int ChildIndex { get; }
+            public int DrawOperationIndex { get; }
+        }
+
+        private void Add(IDrawOperation  node)
+        {
+            if (_drawOperationindex < _node.DrawOperations.Count)
+            {
+                _node.ReplaceDrawOperation(_drawOperationindex, node);
+            }
+            else
+            {
+                _node.AddDrawOperation(node);
+            }
+
+            ++_drawOperationindex;
+        }
+
+        private T NextDrawAs<T>() where T : class, IDrawOperation
+        {
+            return _drawOperationindex < _node.DrawOperations.Count ? _node.DrawOperations[_drawOperationindex] as T : null;
+        }
+
+        private IDictionary<IVisual, Scene> CreateChildScene(IBrush brush)
+        {
+            var visualBrush = brush as VisualBrush;
+
+            if (visualBrush != null)
+            {
+                var visual = visualBrush.Visual;
+
+                if (visual != null)
+                {
+                    (visual as IVisualBrushInitialize)?.EnsureInitialized();
+                    var scene = new Scene(visual);
+                    _sceneBuilder.UpdateAll(scene);
+                    return new Dictionary<IVisual, Scene> { { visualBrush.Visual, scene } };
+                }
+            }
+
+            return null;
+        }
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/GeometryClipNode.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/GeometryClipNode.cs
new file mode 100644
index 00000000000..a11d641151a
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/GeometryClipNode.cs
@@ -0,0 +1,64 @@
+using System;
+using Avalonia.Platform;
+
+namespace Avalonia.Rendering.SceneGraph
+{
+    /// <summary>
+    /// A node in the scene graph which represents a geometry clip push or pop.
+    /// </summary>
+    internal class GeometryClipNode : IDrawOperation
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="GeometryClipNode"/> class that represents a
+        /// geometry clip push.
+        /// </summary>
+        /// <param name="clip">The clip to push.</param>
+        public GeometryClipNode(IGeometryImpl clip)
+        {
+            Clip = clip;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="GeometryClipNode"/> class that represents a
+        /// geometry clip pop.
+        /// </summary>
+        public GeometryClipNode()
+        {
+        }
+
+        /// <inheritdoc/>
+        public Rect Bounds => Rect.Empty;
+
+        /// <summary>
+        /// Gets the clip to be pushed or null if the operation represents a pop.
+        /// </summary>
+        public IGeometryImpl Clip { get; }
+
+        /// <inheritdoc/>
+        public bool HitTest(Point p) => false;
+
+        /// <summary>
+        /// Determines if this draw operation equals another.
+        /// </summary>
+        /// <param name="clip">The clip of the other draw operation.</param>
+        /// <returns>True if the draw operations are the same, otherwise false.</returns>
+        /// <remarks>
+        /// The properties of the other draw operation are passed in as arguments to prevent
+        /// allocation of a not-yet-constructed draw operation object.
+        /// </remarks>
+        public bool Equals(IGeometryImpl clip) => Clip == clip;
+
+        /// <inheritdoc/>
+        public void Render(IDrawingContextImpl context)
+        {
+            if (Clip != null)
+            {
+                context.PushGeometryClip(Clip);
+            }
+            else
+            {
+                context.PopGeometryClip();
+            }
+        }
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/GeometryNode.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/GeometryNode.cs
new file mode 100644
index 00000000000..b884c42d990
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/GeometryNode.cs
@@ -0,0 +1,101 @@
+// Copyright (c) The Avalonia Project. All rights reserved.
+// Licensed under the MIT license. See licence.md file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using Avalonia.Media;
+using Avalonia.Platform;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Rendering.SceneGraph
+{
+    /// <summary>
+    /// A node in the scene graph which represents a geometry draw.
+    /// </summary>
+    internal class GeometryNode : BrushDrawOperation
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="GeometryNode"/> class.
+        /// </summary>
+        /// <param name="transform">The transform.</param>
+        /// <param name="brush">The fill brush.</param>
+        /// <param name="pen">The stroke pen.</param>
+        /// <param name="geometry">The geometry.</param>
+        /// <param name="childScenes">Child scenes for drawing visual brushes.</param>
+        public GeometryNode(
+            Matrix transform,
+            IBrush brush,
+            Pen pen,
+            IGeometryImpl geometry,
+            IDictionary<IVisual, Scene> childScenes = null)
+        {
+            Bounds = geometry.GetRenderBounds(pen?.Thickness ?? 0).TransformToAABB(transform);
+            Transform = transform;
+            Brush = brush?.ToImmutable();
+            Pen = pen?.ToImmutable();
+            Geometry = geometry;
+            ChildScenes = childScenes;
+        }
+
+        /// <inheritdoc/>
+        public override Rect Bounds { get; }
+
+        /// <summary>
+        /// Gets the transform with which the node will be drawn.
+        /// </summary>
+        public Matrix Transform { get; }
+
+        /// <summary>
+        /// Gets the fill brush.
+        /// </summary>
+        public IBrush Brush { get; }
+
+        /// <summary>
+        /// Gets the stroke pen.
+        /// </summary>
+        public Pen Pen { get; }
+
+        /// <summary>
+        /// Gets the geometry to draw.
+        /// </summary>
+        public IGeometryImpl Geometry { get; }
+
+        /// <inheritdoc/>
+        public override IDictionary<IVisual, Scene> ChildScenes { get; }
+
+        /// <summary>
+        /// Determines if this draw operation equals another.
+        /// </summary>
+        /// <param name="transform">The transform of the other draw operation.</param>
+        /// <param name="brush">The fill of the other draw operation.</param>
+        /// <param name="pen">The stroke of the other draw operation.</param>
+        /// <param name="geometry">The geometry of the other draw operation.</param>
+        /// <returns>True if the draw operations are the same, otherwise false.</returns>
+        /// <remarks>
+        /// The properties of the other draw operation are passed in as arguments to prevent
+        /// allocation of a not-yet-constructed draw operation object.
+        /// </remarks>
+        public bool Equals(Matrix transform, IBrush brush, Pen pen, IGeometryImpl geometry)
+        {
+            return transform == Transform &&
+                Equals(brush, Brush) && 
+                pen == Pen &&
+                Equals(geometry, Geometry);
+        }
+
+        /// <inheritdoc/>
+        public override void Render(IDrawingContextImpl context)
+        {
+            context.Transform = Transform;
+            context.DrawGeometry(Brush, Pen, Geometry);
+        }
+
+        /// <inheritdoc/>
+        public override bool HitTest(Point p)
+        {
+            p *= Transform.Invert();
+            return (Brush != null && Geometry.FillContains(p)) || 
+                (Pen != null && Geometry.StrokeContains(Pen, p));
+        }
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/IDrawOperation.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/IDrawOperation.cs
new file mode 100644
index 00000000000..8c3bb72463b
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/IDrawOperation.cs
@@ -0,0 +1,36 @@
+// Copyright (c) The Avalonia Project. All rights reserved.
+// Licensed under the MIT license. See licence.md file in the project root for full license information.
+
+using System;
+using Avalonia.Platform;
+
+namespace Avalonia.Rendering.SceneGraph
+{
+    /// <summary>
+    /// Represents a node in the low-level scene graph that represents geometry.
+    /// </summary>
+    public interface IDrawOperation
+    {
+        /// <summary>
+        /// Gets the bounds of the visible content in the node.
+        /// </summary>
+        Rect Bounds { get; }
+
+        /// <summary>
+        /// Hit test the geometry in this node.
+        /// </summary>
+        /// <param name="p">The point in global coordinates.</param>
+        /// <returns>True if the point hits the node's geometry; otherwise false.</returns>
+        /// <remarks>
+        /// This method does not recurse to child <see cref="IVisualNode"/>s, if you want
+        /// to hit test children they must be hit tested manually.
+        /// </remarks>
+        bool HitTest(Point p);
+
+        /// <summary>
+        /// Renders the node to a drawing context.
+        /// </summary>
+        /// <param name="context">The drawing context.</param>
+        void Render(IDrawingContextImpl context);
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/ISceneBuilder.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/ISceneBuilder.cs
new file mode 100644
index 00000000000..dd993fbb8c2
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/ISceneBuilder.cs
@@ -0,0 +1,24 @@
+using Avalonia.VisualTree;
+
+namespace Avalonia.Rendering.SceneGraph
+{
+    /// <summary>
+    /// Builds a scene graph from a visual tree.
+    /// </summary>
+    public interface ISceneBuilder
+    {
+        /// <summary>
+        /// Builds the initial scene graph for a visual tree.
+        /// </summary>
+        /// <param name="scene">The scene to build.</param>
+        void UpdateAll(Scene scene);
+
+        /// <summary>
+        /// Updates the visual (and potentially its children) in a scene.
+        /// </summary>
+        /// <param name="scene">The scene.</param>
+        /// <param name="visual">The visual to update.</param>
+        /// <returns>True if changes were made, otherwise false.</returns>
+        bool Update(Scene scene, IVisual visual);
+    }
+}
\ No newline at end of file
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/IVisualNode.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/IVisualNode.cs
new file mode 100644
index 00000000000..0d2fc17b957
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/IVisualNode.cs
@@ -0,0 +1,94 @@
+// Copyright (c) The Avalonia Project. All rights reserved.
+// Licensed under the MIT license. See licence.md file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using Avalonia.Media;
+using Avalonia.Platform;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Rendering.SceneGraph
+{
+    /// <summary>
+    /// Represents a node in the low-level scene graph representing an <see cref="IVisual"/>.
+    /// </summary>
+    public interface IVisualNode
+    {
+        /// <summary>
+        /// Gets the visual to which the node relates.
+        /// </summary>
+        IVisual Visual { get; }
+
+        /// <summary>
+        /// Gets the parent scene graph node.
+        /// </summary>
+        IVisualNode Parent { get; }
+
+        /// <summary>
+        /// Gets the transform for the node from global to control coordinates.
+        /// </summary>
+        Matrix Transform { get; }
+
+        /// <summary>
+        /// Gets the bounds for the node's geometry in global coordinates.
+        /// </summary>
+        Rect Bounds { get; }
+
+        /// <summary>
+        /// Gets the clip bounds for the node in global coordinates.
+        /// </summary>
+        /// <remarks>
+        /// This clip does not take into account parent clips, to find the absolute clip bounds
+        /// it is necessary to traverse the tree.
+        /// </remarks>
+        Rect ClipBounds { get; }
+
+        /// <summary>
+        /// Whether the node is clipped to <see cref="ClipBounds"/>.
+        /// </summary>
+        bool ClipToBounds { get; }
+
+        /// <summary>
+        /// Gets the node's clip geometry, if any.
+        /// </summary>
+        IGeometryImpl GeometryClip { get; set; }
+
+        /// <summary>
+        /// Gets a value indicating whether one of the node's ancestors has a geometry clip.
+        /// </summary>
+        bool HasAncestorGeometryClip { get; }
+
+        /// <summary>
+        /// Gets the child scene graph nodes.
+        /// </summary>
+        IReadOnlyList<IVisualNode> Children { get; }
+
+        /// <summary>
+        /// Gets the drawing operations for the visual.
+        /// </summary>
+        IReadOnlyList<IDrawOperation> DrawOperations { get; }
+
+        /// <summary>
+        /// Sets up the drawing context for rendering the node's geometry.
+        /// </summary>
+        /// <param name="context">The drawing context.</param>
+        void BeginRender(IDrawingContextImpl context);
+
+        /// <summary>
+        /// Resets the drawing context after rendering the node's geometry.
+        /// </summary>
+        /// <param name="context">The drawing context.</param>
+        void EndRender(IDrawingContextImpl context);
+
+        /// <summary>
+        /// Hit test the geometry in this node.
+        /// </summary>
+        /// <param name="p">The point in global coordinates.</param>
+        /// <returns>True if the point hits the node's geometry; otherwise false.</returns>
+        /// <remarks>
+        /// This method does not recurse to child <see cref="IVisualNode"/>s, if you want
+        /// to hit test children they must be hit tested manually.
+        /// </remarks>
+        bool HitTest(Point p);
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/ImageNode.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/ImageNode.cs
new file mode 100644
index 00000000000..4a50f12095b
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/ImageNode.cs
@@ -0,0 +1,94 @@
+// Copyright (c) The Avalonia Project. All rights reserved.
+// Licensed under the MIT license. See licence.md file in the project root for full license information.
+
+using System;
+using Avalonia.Platform;
+
+namespace Avalonia.Rendering.SceneGraph
+{
+    /// <summary>
+    /// A node in the scene graph which represents an image draw.
+    /// </summary>
+    internal class ImageNode : IDrawOperation
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ImageNode"/> class.
+        /// </summary>
+        /// <param name="transform">The transform.</param>
+        /// <param name="source">The image to draw.</param>
+        /// <param name="opacity">The draw opacity.</param>
+        /// <param name="sourceRect">The source rect.</param>
+        /// <param name="destRect">The destination rect.</param>
+        public ImageNode(Matrix transform, IBitmapImpl source, double opacity, Rect sourceRect, Rect destRect)
+        {
+            Bounds = destRect.TransformToAABB(transform);
+            Transform = transform;
+            Source = source;
+            Opacity = opacity;
+            SourceRect = sourceRect;
+            DestRect = destRect;
+        }
+
+        /// <inheritdoc/>
+        public Rect Bounds { get; }
+
+        /// <summary>
+        /// Gets the transform with which the node will be drawn.
+        /// </summary>
+        public Matrix Transform { get; }
+
+        /// <summary>
+        /// Gets the image to draw.
+        /// </summary>
+        public IBitmapImpl Source { get; }
+
+        /// <summary>
+        /// Gets the draw opacity.
+        /// </summary>
+        public double Opacity { get; }
+
+        /// <summary>
+        /// Gets the source rect.
+        /// </summary>
+        public Rect SourceRect { get; }
+
+        /// <summary>
+        /// Gets the destination rect.
+        /// </summary>
+        public Rect DestRect { get; }
+
+        /// <summary>
+        /// Determines if this draw operation equals another.
+        /// </summary>
+        /// <param name="transform">The transform of the other draw operation.</param>
+        /// <param name="source">The image of the other draw operation.</param>
+        /// <param name="opacity">The opacity of the other draw operation.</param>
+        /// <param name="sourceRect">The source rect of the other draw operation.</param>
+        /// <param name="destRect">The dest rect of the other draw operation.</param>
+        /// <returns>True if the draw operations are the same, otherwise false.</returns>
+        /// <remarks>
+        /// The properties of the other draw operation are passed in as arguments to prevent
+        /// allocation of a not-yet-constructed draw operation object.
+        /// </remarks>
+        public bool Equals(Matrix transform, IBitmapImpl source, double opacity, Rect sourceRect, Rect destRect)
+        {
+            return transform == Transform &&
+                Equals(source, Source) &&
+                opacity == Opacity &&
+                sourceRect == SourceRect &&
+                destRect == DestRect;
+        }
+
+        /// <inheritdoc/>
+        public void Render(IDrawingContextImpl context)
+        {
+            // TODO: Probably need to introduce some kind of locking mechanism in the case of
+            // WriteableBitmap.
+            context.Transform = Transform;
+            context.DrawImage(Source, Opacity, SourceRect, DestRect);
+        }
+
+        /// <inheritdoc/>
+        public bool HitTest(Point p) => Bounds.Contains(p);
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/LineNode.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/LineNode.cs
new file mode 100644
index 00000000000..7ed188de942
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/LineNode.cs
@@ -0,0 +1,95 @@
+// Copyright (c) The Avalonia Project. All rights reserved.
+// Licensed under the MIT license. See licence.md file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using Avalonia.Media;
+using Avalonia.Platform;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Rendering.SceneGraph
+{
+    /// <summary>
+    /// A node in the scene graph which represents a line draw.
+    /// </summary>
+    internal class LineNode : BrushDrawOperation
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="GeometryNode"/> class.
+        /// </summary>
+        /// <param name="transform">The transform.</param>
+        /// <param name="pen">The stroke pen.</param>
+        /// <param name="p1">The start point of the line.</param>
+        /// <param name="p2">The end point of the line.</param>
+        /// <param name="childScenes">Child scenes for drawing visual brushes.</param>
+        public LineNode(
+            Matrix transform,
+            Pen pen,
+            Point p1,
+            Point p2,
+            IDictionary<IVisual, Scene> childScenes = null)
+        {
+            Bounds = new Rect(P1, P2);
+            Transform = transform;
+            Pen = pen?.ToImmutable();
+            P1 = p1;
+            P2 = p2;
+            ChildScenes = childScenes;
+        }
+
+        /// <inheritdoc/>
+        public override Rect Bounds { get; }
+
+        /// <summary>
+        /// Gets the transform with which the node will be drawn.
+        /// </summary>
+        public Matrix Transform { get; }
+
+        /// <summary>
+        /// Gets the stroke pen.
+        /// </summary>
+        public Pen Pen { get; }
+
+        /// <summary>
+        /// Gets the start point of the line.
+        /// </summary>
+        public Point P1 { get; }
+
+        /// <summary>
+        /// Gets the end point of the line.
+        /// </summary>
+        public Point P2 { get; }
+
+        /// <inheritdoc/>
+        public override IDictionary<IVisual, Scene> ChildScenes { get; }
+
+        /// <summary>
+        /// Determines if this draw operation equals another.
+        /// </summary>
+        /// <param name="transform">The transform of the other draw operation.</param>
+        /// <param name="pen">The stroke of the other draw operation.</param>
+        /// <param name="p1">The start point of the other draw operation.</param>
+        /// <param name="p2">The end point of the other draw operation.</param>
+        /// <returns>True if the draw operations are the same, otherwise false.</returns>
+        /// <remarks>
+        /// The properties of the other draw operation are passed in as arguments to prevent
+        /// allocation of a not-yet-constructed draw operation object.
+        /// </remarks>
+        public bool Equals(Matrix transform, Pen pen, Point p1, Point p2)
+        {
+            return transform == Transform && pen == Pen && p1 == P1 && p2 == P2;
+        }
+
+        public override void Render(IDrawingContextImpl context)
+        {
+            context.Transform = Transform;
+            context.DrawLine(Pen, P1, P2);
+        }
+
+        public override bool HitTest(Point p)
+        {
+            // TODO: Implement line hit testing.
+            return false;
+        }
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/OpacityMaskNode.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/OpacityMaskNode.cs
new file mode 100644
index 00000000000..c40869724f8
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/OpacityMaskNode.cs
@@ -0,0 +1,80 @@
+using System;
+using System.Collections.Generic;
+using Avalonia.Media;
+using Avalonia.Platform;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Rendering.SceneGraph
+{
+    /// <summary>
+    /// A node in the scene graph which represents an opacity mask push or pop.
+    /// </summary>
+    internal class OpacityMaskNode : BrushDrawOperation
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OpacityMaskNode"/> class that represents an
+        /// opacity mask push.
+        /// </summary>
+        /// <param name="mask">The opacity mask to push.</param>
+        /// <param name="bounds">The bounds of the mask.</param>
+        /// <param name="childScenes">Child scenes for drawing visual brushes.</param>
+        public OpacityMaskNode(IBrush mask, Rect bounds, IDictionary<IVisual, Scene> childScenes = null)
+        {
+            Mask = mask?.ToImmutable();
+            MaskBounds = bounds;
+            ChildScenes = childScenes;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OpacityMaskNode"/> class that represents an
+        /// opacity mask pop.
+        /// </summary>
+        public OpacityMaskNode()
+        {
+        }
+
+        /// <inheritdoc/>
+        public override Rect Bounds => Rect.Empty;
+
+        /// <summary>
+        /// Gets the mask to be pushed or null if the operation represents a pop.
+        /// </summary>
+        public IBrush Mask { get; }
+
+        /// <summary>
+        /// Gets the bounds of the opacity mask or null if the operation represents a pop.
+        /// </summary>
+        public Rect? MaskBounds { get; }
+
+        /// <inheritdoc/>
+        public override IDictionary<IVisual, Scene> ChildScenes { get; }
+
+        /// <inheritdoc/>
+        public override bool HitTest(Point p) => false;
+
+        /// <summary>
+        /// Determines if this draw operation equals another.
+        /// </summary>
+        /// <param name="mask">The opacity mask of the other draw operation.</param>
+        /// <param name="bounds">The opacity mask bounds of the other draw operation.</param>
+        /// <returns>True if the draw operations are the same, otherwise false.</returns>
+        /// <remarks>
+        /// The properties of the other draw operation are passed in as arguments to prevent
+        /// allocation of a not-yet-constructed draw operation object.
+        /// </remarks>
+        public bool Equals(IBrush mask, Rect? bounds) => Mask == mask && MaskBounds == bounds;
+
+        /// <inheritdoc/>
+        public override void Render(IDrawingContextImpl context)
+        {
+            if (Mask != null)
+            {
+                context.PushOpacityMask(Mask, MaskBounds.Value);
+            }
+            else
+            {
+                context.PopOpacityMask();
+            }
+        }
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/OpacityNode.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/OpacityNode.cs
new file mode 100644
index 00000000000..097bf15828f
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/OpacityNode.cs
@@ -0,0 +1,64 @@
+using System;
+using Avalonia.Platform;
+
+namespace Avalonia.Rendering.SceneGraph
+{
+    /// <summary>
+    /// A node in the scene graph which represents an opacity push or pop.
+    /// </summary>
+    internal class OpacityNode : IDrawOperation
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OpacityNode"/> class that represents an
+        /// opacity push.
+        /// </summary>
+        /// <param name="opacity">The opacity to push.</param>
+        public OpacityNode(double opacity)
+        {
+            Opacity = opacity;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OpacityNode"/> class that represents an
+        /// opacity pop.
+        /// </summary>
+        public OpacityNode()
+        {
+        }
+
+        /// <inheritdoc/>
+        public Rect Bounds => Rect.Empty;
+
+        /// <summary>
+        /// Gets the opacity to be pushed or null if the operation represents a pop.
+        /// </summary>
+        public double? Opacity { get; }
+
+        /// <inheritdoc/>
+        public bool HitTest(Point p) => false;
+
+        /// <summary>
+        /// Determines if this draw operation equals another.
+        /// </summary>
+        /// <param name="opacity">The opacity of the other draw operation.</param>
+        /// <returns>True if the draw operations are the same, otherwise false.</returns>
+        /// <remarks>
+        /// The properties of the other draw operation are passed in as arguments to prevent
+        /// allocation of a not-yet-constructed draw operation object.
+        /// </remarks>
+        public bool Equals(double? opacity) => Opacity == opacity;
+
+        /// <inheritdoc/>
+        public void Render(IDrawingContextImpl context)
+        {
+            if (Opacity.HasValue)
+            {
+                context.PushOpacity(Opacity.Value);
+            }
+            else
+            {
+                context.PopOpacity();
+            }
+        }
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/RectangleNode.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/RectangleNode.cs
new file mode 100644
index 00000000000..2affc454b5a
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/RectangleNode.cs
@@ -0,0 +1,116 @@
+// Copyright (c) The Avalonia Project. All rights reserved.
+// Licensed under the MIT license. See licence.md file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using Avalonia.Media;
+using Avalonia.Platform;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Rendering.SceneGraph
+{
+    /// <summary>
+    /// A node in the scene graph which represents a rectangle draw.
+    /// </summary>
+    internal class RectangleNode : BrushDrawOperation
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RectangleNode"/> class.
+        /// </summary>
+        /// <param name="transform">The transform.</param>
+        /// <param name="brush">The fill brush.</param>
+        /// <param name="pen">The stroke pen.</param>
+        /// <param name="rect">The rectanle to draw.</param>
+        /// <param name="cornerRadius">The rectangle corner radius.</param>
+        /// <param name="childScenes">Child scenes for drawing visual brushes.</param>
+        public RectangleNode(
+            Matrix transform,
+            IBrush brush,
+            Pen pen,
+            Rect rect,
+            float cornerRadius,
+            IDictionary<IVisual, Scene> childScenes = null)
+        {
+            Bounds = rect.TransformToAABB(transform).Inflate(pen?.Thickness ?? 0);
+            Transform = transform;
+            Brush = brush?.ToImmutable();
+            Pen = pen?.ToImmutable();
+            Rect = rect;
+            CornerRadius = cornerRadius;
+            ChildScenes = childScenes;
+        }
+
+        /// <inheritdoc/>
+        public override Rect Bounds { get; }
+
+        /// <summary>
+        /// Gets the transform with which the node will be drawn.
+        /// </summary>
+        public Matrix Transform { get; }
+
+        /// <summary>
+        /// Gets the fill brush.
+        /// </summary>
+        public IBrush Brush { get; }
+
+        /// <summary>
+        /// Gets the stroke pen.
+        /// </summary>
+        public Pen Pen { get; }
+
+        /// <summary>
+        /// Gets the rectangle to draw.
+        /// </summary>
+        public Rect Rect { get; }
+
+        /// <summary>
+        /// Gets the rectangle corner radius.
+        /// </summary>
+        public float CornerRadius { get; }
+
+        /// <inheritdoc/>
+        public override IDictionary<IVisual, Scene> ChildScenes { get; }
+
+        /// <summary>
+        /// Determines if this draw operation equals another.
+        /// </summary>
+        /// <param name="transform">The transform of the other draw operation.</param>
+        /// <param name="brush">The fill of the other draw operation.</param>
+        /// <param name="pen">The stroke of the other draw operation.</param>
+        /// <param name="rect">The rectangle of the other draw operation.</param>
+        /// <param name="cornerRadius">The rectangle corner radius of the other draw operation.</param>
+        /// <returns>True if the draw operations are the same, otherwise false.</returns>
+        /// <remarks>
+        /// The properties of the other draw operation are passed in as arguments to prevent
+        /// allocation of a not-yet-constructed draw operation object.
+        /// </remarks>
+        public bool Equals(Matrix transform, IBrush brush, Pen pen, Rect rect, float cornerRadius)
+        {
+            return transform == Transform &&
+                Equals(brush, Brush) &&
+                pen == Pen &&
+                rect == Rect &&
+                cornerRadius == CornerRadius;
+        }
+
+        /// <inheritdoc/>
+        public override void Render(IDrawingContextImpl context)
+        {
+            context.Transform = Transform;
+
+            if (Brush != null)
+            {
+                context.FillRectangle(Brush, Rect, CornerRadius);
+            }
+
+            if (Pen != null)
+            {
+                context.DrawRectangle(Pen, Rect, CornerRadius);
+            }
+        }
+
+        // TODO: This doesn't respect CornerRadius yet.
+        /// <inheritdoc/>
+        public override bool HitTest(Point p) => Bounds.Contains(p);
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/Scene.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/Scene.cs
new file mode 100644
index 00000000000..a85fd367637
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/Scene.cs
@@ -0,0 +1,184 @@
+// Copyright (c) The Avalonia Project. All rights reserved.
+// Licensed under the MIT license. See licence.md file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Rendering.SceneGraph
+{
+    /// <summary>
+    /// Represents a scene graph used by the <see cref="DeferredRenderer"/>.
+    /// </summary>
+    public class Scene
+    {
+        private Dictionary<IVisual, IVisualNode> _index;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Scene"/> class.
+        /// </summary>
+        /// <param name="rootVisual">The root visual to draw.</param>
+        public Scene(IVisual rootVisual)
+            : this(
+                new VisualNode(rootVisual, null),
+                new Dictionary<IVisual, IVisualNode>(),
+                new SceneLayers(rootVisual),
+                0)
+        {
+            _index.Add(rootVisual, Root);
+        }
+
+        private Scene(VisualNode root, Dictionary<IVisual, IVisualNode> index, SceneLayers layers, int generation)
+        {
+            Contract.Requires<ArgumentNullException>(root != null);
+
+            var renderRoot = root.Visual as IRenderRoot;
+
+            _index = index;
+            Root = root;
+            Layers = layers;
+            Generation = generation;
+            root.LayerRoot = root.Visual;
+        }
+
+        /// <summary>
+        /// Gets a value identifying the scene's generation. This is incremented each time the scene is cloned.
+        /// </summary>
+        public int Generation { get; }
+
+        /// <summary>
+        /// Gets the layers for the scene.
+        /// </summary>
+        public SceneLayers Layers { get; }
+
+        /// <summary>
+        /// Gets the root node of the scene graph.
+        /// </summary>
+        public IVisualNode Root { get; }
+
+        /// <summary>
+        /// Gets or sets the size of the scene in device independent pixels.
+        /// </summary>
+        public Size Size { get; set; }
+
+        /// <summary>
+        /// Gets or sets the scene scaling.
+        /// </summary>
+        public double Scaling { get; set; } = 1;
+
+        /// <summary>
+        /// Adds a node to the scene index.
+        /// </summary>
+        /// <param name="node">The node.</param>
+        public void Add(IVisualNode node)
+        {
+            Contract.Requires<ArgumentNullException>(node != null);
+
+            _index.Add(node.Visual, node);
+        }
+
+        /// <summary>
+        /// Clones the scene.
+        /// </summary>
+        /// <returns>The cloned scene.</returns>
+        public Scene Clone()
+        {
+            var index = new Dictionary<IVisual, IVisualNode>();
+            var root = Clone((VisualNode)Root, null, index);
+
+            var result = new Scene(root, index, Layers.Clone(), Generation + 1)
+            {
+                Size = Size,
+                Scaling = Scaling,
+            };
+
+            return result;
+        }
+
+        /// <summary>
+        /// Tries to find a node in the scene graph representing the specified visual.
+        /// </summary>
+        /// <param name="visual">The visual.</param>
+        /// <returns>
+        /// The node representing the visual or null if it could not be found.
+        /// </returns>
+        public IVisualNode FindNode(IVisual visual)
+        {
+            IVisualNode node;
+            _index.TryGetValue(visual, out node);
+            return node;
+        }
+
+        /// <summary>
+        /// Gets the visuals at a point in the scene.
+        /// </summary>
+        /// <param name="p">The point.</param>
+        /// <param name="filter">A filter. May be null.</param>
+        /// <returns>The visuals at the specified point.</returns>
+        public IEnumerable<IVisual> HitTest(Point p, Func<IVisual, bool> filter)
+        {
+            return HitTest(Root, p, null, filter);
+        }
+
+        /// <summary>
+        /// Removes a node from the scene index.
+        /// </summary>
+        /// <param name="node">The node.</param>
+        public void Remove(IVisualNode node)
+        {
+            Contract.Requires<ArgumentNullException>(node != null);
+
+            _index.Remove(node.Visual);
+        }
+
+        private VisualNode Clone(VisualNode source, IVisualNode parent, Dictionary<IVisual, IVisualNode> index)
+        {
+            var result = source.Clone(parent);
+
+            index.Add(result.Visual, result);
+
+            foreach (var child in source.Children)
+            {
+                result.AddChild(Clone((VisualNode)child, result, index));
+            }
+
+            return result;
+        }
+
+        private IEnumerable<IVisual> HitTest(IVisualNode node, Point p, Rect? clip, Func<IVisual, bool> filter)
+        {
+            if (filter?.Invoke(node.Visual) != false)
+            {
+                var clipped = false;
+
+                if (node.ClipToBounds)
+                {
+                    clip = clip == null ? node.ClipBounds : clip.Value.Intersect(node.ClipBounds);
+                    clipped = !clip.Value.Contains(p);
+                }
+
+                if (node.GeometryClip != null)
+                {
+                    var controlPoint = Root.Visual.TranslatePoint(p, node.Visual);
+                    clipped = !node.GeometryClip.FillContains(controlPoint);
+                }
+
+                if (!clipped)
+                {
+                    for (var i = node.Children.Count - 1; i >= 0; --i)
+                    {
+                        foreach (var h in HitTest(node.Children[i], p, clip, filter))
+                        {
+                            yield return h;
+                        }
+                    }
+
+                    if (node.HitTest(p))
+                    {
+                        yield return node.Visual;
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/SceneBuilder.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/SceneBuilder.cs
new file mode 100644
index 00000000000..afdf488b313
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/SceneBuilder.cs
@@ -0,0 +1,384 @@
+// Copyright (c) The Avalonia Project. All rights reserved.
+// Licensed under the MIT license. See licence.md file in the project root for full license information.
+
+using System;
+using System.Linq;
+using Avalonia.Media;
+using Avalonia.Platform;
+using Avalonia.Threading;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Rendering.SceneGraph
+{
+    /// <summary>
+    /// Builds a scene graph from a visual tree.
+    /// </summary>
+    public class SceneBuilder : ISceneBuilder
+    {
+        /// <inheritdoc/>
+        public void UpdateAll(Scene scene)
+        {
+            Contract.Requires<ArgumentNullException>(scene != null);
+            Dispatcher.UIThread.VerifyAccess();
+
+            UpdateSize(scene);
+            scene.Layers.GetOrAdd(scene.Root.Visual);
+
+            using (var impl = new DeferredDrawingContextImpl(this, scene.Layers))
+            using (var context = new DrawingContext(impl))
+            {
+                Update(context, scene, (VisualNode)scene.Root, scene.Root.Visual.Bounds, true);
+            }
+        }
+
+        /// <inheritdoc/>
+        public bool Update(Scene scene, IVisual visual)
+        {
+            Contract.Requires<ArgumentNullException>(scene != null);
+            Contract.Requires<ArgumentNullException>(visual != null);
+            Dispatcher.UIThread.VerifyAccess();
+
+            var node = (VisualNode)scene.FindNode(visual);
+
+            if (visual == scene.Root.Visual)
+            {
+                UpdateSize(scene);
+            }
+
+            if (visual.VisualRoot != null)
+            {
+                if (visual.IsVisible)
+                {
+                    // If the node isn't yet part of the scene, find the nearest ancestor that is.
+                    node = node ?? FindExistingAncestor(scene, visual);
+
+                    // We don't need to do anything if this part of the tree has already been fully
+                    // updated.
+                    if (node != null && !node.SubTreeUpdated)
+                    {
+                        // If the control we've been asked to update isn't part of the scene then
+                        // we're carrying out an add operation, so recurse and add all the
+                        // descendents too.
+                        var recurse = node.Visual != visual;
+
+                        using (var impl = new DeferredDrawingContextImpl(this, scene.Layers))
+                        using (var context = new DrawingContext(impl))
+                        {
+                            var clip = scene.Root.Visual.Bounds;
+
+                            if (node.Parent != null)
+                            {
+                                context.PushPostTransform(node.Parent.Transform);
+                                clip = node.Parent.ClipBounds;
+                            }
+
+                            using (context.PushTransformContainer())
+                            {
+                                Update(context, scene, node, clip, recurse);
+                            }
+                        }
+
+                        return true;
+                    }
+                }
+                else
+                {
+                    if (node != null)
+                    {
+                        // The control has been hidden so remove it from its parent and deindex the
+                        // node and its descendents.
+                        ((VisualNode)node.Parent)?.RemoveChild(node);
+                        Deindex(scene, node);
+                        return true;
+                    }
+                }
+            }
+            else if (node != null)
+            {
+                // The control has been removed so remove it from its parent and deindex the
+                // node and its descendents.
+                var trim = FindFirstDeadAncestor(scene, node);
+                ((VisualNode)trim.Parent).RemoveChild(trim);
+                Deindex(scene, trim);
+                return true;
+            }
+
+            return false;
+        }
+
+        private static VisualNode FindExistingAncestor(Scene scene, IVisual visual)
+        {
+            var node = scene.FindNode(visual);
+
+            while (node == null && visual.IsVisible)
+            {
+                visual = visual.VisualParent;
+                node = scene.FindNode(visual);
+            }
+
+            return visual.IsVisible ? (VisualNode)node : null;
+        }
+
+        private static VisualNode FindFirstDeadAncestor(Scene scene, IVisualNode node)
+        {
+            var parent = node.Parent;
+
+            while (parent.Visual.VisualRoot == null)
+            {
+                node = parent;
+                parent = node.Parent;
+            }
+
+            return (VisualNode)node;
+        }
+
+        private static void Update(DrawingContext context, Scene scene, VisualNode node, Rect clip, bool forceRecurse)
+        {
+            var visual = node.Visual;
+            var opacity = visual.Opacity;
+            var clipToBounds = visual.ClipToBounds;
+            var bounds = new Rect(visual.Bounds.Size);
+            var contextImpl = (DeferredDrawingContextImpl)context.PlatformImpl;
+
+            contextImpl.Layers.Find(node.LayerRoot)?.Dirty.Add(node.Bounds);
+
+            if (visual.IsVisible)
+            {
+                var m = Matrix.CreateTranslation(visual.Bounds.Position);
+
+                var renderTransform = Matrix.Identity;
+
+                if (visual.RenderTransform != null)
+                {
+                    var origin = visual.RenderTransformOrigin.ToPixels(new Size(visual.Bounds.Width, visual.Bounds.Height));
+                    var offset = Matrix.CreateTranslation(origin);
+                    renderTransform = (-offset) * visual.RenderTransform.Value * (offset);
+                }
+
+                m = renderTransform * m;
+
+                using (contextImpl.BeginUpdate(node))
+                using (context.PushPostTransform(m))
+                using (context.PushTransformContainer())
+                {
+                    var startLayer = opacity < 1 || visual.OpacityMask != null;
+
+                    forceRecurse = forceRecurse || node.Transform != contextImpl.Transform;
+
+                    node.Transform = contextImpl.Transform;
+                    node.ClipBounds = bounds.TransformToAABB(node.Transform).Intersect(clip);
+                    node.ClipToBounds = clipToBounds;
+                    node.GeometryClip = visual.Clip?.PlatformImpl;
+                    node.Opacity = opacity;
+                    node.OpacityMask = visual.OpacityMask;
+
+                    if (startLayer)
+                    {
+                        if (node.LayerRoot != visual)
+                        {
+                            MakeLayer(scene, node);
+                        }
+                        else
+                        {
+                            UpdateLayer(node, scene.Layers[node.LayerRoot]);
+                        }
+                    }
+                    else if (!startLayer && node.LayerRoot == node.Visual && node.Parent != null)
+                    {
+                        ClearLayer(scene, node);
+                    }
+
+                    if (node.ClipToBounds)
+                    {
+                        clip = clip.Intersect(node.ClipBounds);
+                    }
+
+                    try
+                    {
+                        visual.Render(context);
+                    }
+                    catch { }
+
+                    if (visual is Visual)
+                    {
+                        var transformed = new TransformedBounds(new Rect(visual.Bounds.Size), clip, node.Transform);
+                        BoundsTracker.SetTransformedBounds((Visual)visual, transformed);
+                    }
+
+                    if (forceRecurse)
+                    {
+                        foreach (var child in visual.VisualChildren.OrderBy(x => x, ZIndexComparer.Instance))
+                        {
+                            var childNode = scene.FindNode(child) ?? CreateNode(scene, child, node);
+                            Update(context, scene, (VisualNode)childNode, clip, forceRecurse);
+                        }
+
+                        node.SubTreeUpdated = true;
+                        contextImpl.TrimChildren();
+                    }
+                }
+            }
+        }
+
+        private void UpdateSize(Scene scene)
+        {
+            var renderRoot = scene.Root.Visual as IRenderRoot;
+            var newSize = renderRoot?.ClientSize ?? scene.Root.Visual.Bounds.Size;
+
+            scene.Scaling = renderRoot?.RenderScaling ?? 1;
+
+            if (scene.Size != newSize)
+            {
+                var oldSize = scene.Size;
+
+                scene.Size = newSize;
+
+                Rect horizontalDirtyRect = Rect.Empty;
+                Rect verticalDirtyRect = Rect.Empty;
+
+                if (newSize.Width > oldSize.Width)
+                {
+                    horizontalDirtyRect = new Rect(oldSize.Width, 0, newSize.Width - oldSize.Width, oldSize.Height);
+                }
+
+                if (newSize.Height > oldSize.Height)
+                {
+                    verticalDirtyRect = new Rect(0, oldSize.Height, newSize.Width, newSize.Height - oldSize.Height);
+                }
+
+                foreach (var layer in scene.Layers)
+                {
+                    layer.Dirty.Add(horizontalDirtyRect);
+                    layer.Dirty.Add(verticalDirtyRect);
+                }
+            }
+        }
+
+        private static VisualNode CreateNode(Scene scene, IVisual visual, VisualNode parent)
+        {
+            var node = new VisualNode(visual, parent);
+            node.LayerRoot = parent.LayerRoot;
+            scene.Add(node);
+            return node;
+        }
+
+        private static void Deindex(Scene scene, VisualNode node)
+        {
+            scene.Remove(node);
+            node.SubTreeUpdated = true;
+
+            scene.Layers[node.LayerRoot].Dirty.Add(node.Bounds);
+
+            if (node.Visual is Visual v)
+            {
+                BoundsTracker.SetTransformedBounds(v, null);
+            }
+
+            foreach (VisualNode child in node.Children)
+            {
+                var geometry = child as IDrawOperation;
+
+                if (child is VisualNode visual)
+                {
+                    Deindex(scene, visual);
+                }
+            }
+
+            if (node.LayerRoot == node.Visual && node.Visual != scene.Root.Visual)
+            {
+                scene.Layers.Remove(node.LayerRoot);
+            }
+        }
+
+        private static void ClearLayer(Scene scene, VisualNode node)
+        {
+            var parent = (VisualNode)node.Parent;
+            var oldLayerRoot = node.LayerRoot;
+            var newLayerRoot = parent.LayerRoot;
+            var existingDirtyRects = scene.Layers[node.LayerRoot].Dirty;
+            var newDirtyRects = scene.Layers[newLayerRoot].Dirty;
+
+            existingDirtyRects.Coalesce();
+
+            foreach (var r in existingDirtyRects)
+            {
+                newDirtyRects.Add(r);
+            }
+
+            var oldLayer = scene.Layers[oldLayerRoot];
+            PropagateLayer(node, scene.Layers[newLayerRoot], oldLayer);
+            scene.Layers.Remove(oldLayer);
+        }
+
+        private static void MakeLayer(Scene scene, VisualNode node)
+        {
+            var oldLayerRoot = node.LayerRoot;
+            var layer = scene.Layers.Add(node.Visual);
+            var oldLayer = scene.Layers[oldLayerRoot];
+
+            UpdateLayer(node, layer);
+            PropagateLayer(node, layer, scene.Layers[oldLayerRoot]);
+        }
+
+        private static void UpdateLayer(VisualNode node, SceneLayer layer)
+        {
+            layer.Opacity = node.Visual.Opacity;
+
+            if (node.Visual.OpacityMask != null)
+            {
+                layer.OpacityMask = node.Visual.OpacityMask?.ToImmutable();
+                layer.OpacityMaskRect = node.ClipBounds;
+            }
+            else
+            {
+                layer.OpacityMask = null;
+                layer.OpacityMaskRect = Rect.Empty;
+            }
+
+            layer.GeometryClip = node.HasAncestorGeometryClip ?
+                CreateLayerGeometryClip(node) :
+                null;
+        }
+
+        private static void PropagateLayer(VisualNode node, SceneLayer layer, SceneLayer oldLayer)
+        {
+            node.LayerRoot = layer.LayerRoot;
+
+            layer.Dirty.Add(node.Bounds);
+            oldLayer.Dirty.Add(node.Bounds);
+
+            foreach (VisualNode child in node.Children)
+            {
+                // If the child is not the start of a new layer, recurse.
+                if (child.LayerRoot != child.Visual)
+                {
+                    PropagateLayer(child, layer, oldLayer);
+                }
+            }
+        }
+
+        private static IGeometryImpl CreateLayerGeometryClip(VisualNode node)
+        {
+            IGeometryImpl result = null;
+
+            for (;;)
+            {
+                node = (VisualNode)node.Parent;
+
+                if (node == null || (node.GeometryClip == null && !node.HasAncestorGeometryClip))
+                {
+                    break;
+                }
+
+                if (node?.GeometryClip != null)
+                {
+                    var transformed = node.GeometryClip.WithTransform(node.Transform);
+
+                    result = result == null ? transformed : result.Intersect(transformed);
+                }
+            }
+
+            return result;
+        }
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/SceneLayer.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/SceneLayer.cs
new file mode 100644
index 00000000000..77ad96a2220
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/SceneLayer.cs
@@ -0,0 +1,75 @@
+using System;
+using Avalonia.Media;
+using Avalonia.Platform;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Rendering.SceneGraph
+{
+    /// <summary>
+    /// Represents a layer in a <see cref="Scene"/>.
+    /// </summary>
+    public class SceneLayer
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SceneLayer"/> class.
+        /// </summary>
+        /// <param name="layerRoot">The visual at the root of the layer.</param>
+        /// <param name="distanceFromRoot">The distance from the scene root.</param>
+        public SceneLayer(IVisual layerRoot, int distanceFromRoot)
+        {
+            LayerRoot = layerRoot;
+            Dirty = new DirtyRects();
+            DistanceFromRoot = distanceFromRoot;
+        }
+
+        /// <summary>
+        /// Clones the layer.
+        /// </summary>
+        /// <returns>The cloned layer.</returns>
+        public SceneLayer Clone()
+        {
+            return new SceneLayer(LayerRoot, DistanceFromRoot)
+            {
+                Opacity = Opacity,
+                OpacityMask = OpacityMask,
+                OpacityMaskRect = OpacityMaskRect,
+                GeometryClip = GeometryClip,
+            };
+        }
+
+        /// <summary>
+        /// Gets the visual at the root of the layer.
+        /// </summary>
+        public IVisual LayerRoot { get; }
+
+        /// <summary>
+        /// Gets the distance of the layer root from the root of the scene.
+        /// </summary>
+        public int DistanceFromRoot { get; }
+
+        /// <summary>
+        /// Gets or sets the opacity of the layer.
+        /// </summary>
+        public double Opacity { get; set; } = 1;
+
+        /// <summary>
+        /// Gets or sets the opacity mask for the layer.
+        /// </summary>
+        public IBrush OpacityMask { get; set; }
+
+        /// <summary>
+        /// Gets or sets the target rectangle for the layer opacity mask.
+        /// </summary>
+        public Rect OpacityMaskRect { get; set; }
+
+        /// <summary>
+        /// Gets the layer's geometry clip.
+        /// </summary>
+        public IGeometryImpl GeometryClip { get; set; }
+
+        /// <summary>
+        /// Gets the dirty rectangles for the layer.
+        /// </summary>
+        internal DirtyRects Dirty { get; }
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/SceneLayers.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/SceneLayers.cs
new file mode 100644
index 00000000000..5960b4f5607
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/SceneLayers.cs
@@ -0,0 +1,199 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Rendering.SceneGraph
+{
+    /// <summary>
+    /// Holds a collection of layers for a <see cref="Scene"/>.
+    /// </summary>
+    public class SceneLayers : IEnumerable<SceneLayer>
+    {
+        private readonly IVisual _root;
+        private readonly List<SceneLayer> _inner = new List<SceneLayer>();
+        private readonly Dictionary<IVisual, SceneLayer> _index = new Dictionary<IVisual, SceneLayer>();
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SceneLayers"/> class.
+        /// </summary>
+        /// <param name="root">The scene's root visual.</param>
+        public SceneLayers(IVisual root)
+        {
+            _root = root;
+        }
+
+        /// <summary>
+        /// Gets the number of layers in the scene.
+        /// </summary>
+        public int Count => _inner.Count;
+
+        /// <summary>
+        /// Gets a value indicating whether any of the layers have a dirty region.
+        /// </summary>
+        public bool HasDirty
+        {
+            get
+            {
+                foreach (var layer in _inner)
+                {
+                    if (!layer.Dirty.IsEmpty)
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Gets a layer by index.
+        /// </summary>
+        /// <param name="index">The index of the layer.</param>
+        /// <returns>The layer.</returns>
+        public SceneLayer this[int index] => _inner[index];
+
+        /// <summary>
+        /// Gets a layer by its root visual.
+        /// </summary>
+        /// <param name="visual">The layer's root visual.</param>
+        /// <returns>The layer.</returns>
+        public SceneLayer this[IVisual visual] => _index[visual];
+
+        /// <summary>
+        /// Adds a layer to the scene.
+        /// </summary>
+        /// <param name="layerRoot">The root visual of the layer.</param>
+        /// <returns>The created layer.</returns>
+        public SceneLayer Add(IVisual layerRoot)
+        {
+            Contract.Requires<ArgumentNullException>(layerRoot != null);
+
+            var distance = layerRoot.CalculateDistanceFromAncestor(_root);
+            var layer = new SceneLayer(layerRoot, distance);
+            var insert = FindInsertIndex(layer);
+            _index.Add(layerRoot, layer);
+            _inner.Insert(insert, layer);
+            return layer;
+        }
+
+        /// <summary>
+        /// Makes a deep clone of the layers.
+        /// </summary>
+        /// <returns>The cloned layers.</returns>
+        public SceneLayers Clone()
+        {
+            var result = new SceneLayers(_root);
+
+            foreach (var src in _inner)
+            {
+                var dest = src.Clone();
+                result._index.Add(dest.LayerRoot, dest);
+                result._inner.Add(dest);
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Tests whether a layer exists with the specified root visual.
+        /// </summary>
+        /// <param name="layerRoot">The root visual.</param>
+        /// <returns>
+        /// True if a layer exists with the specified root visual, otherwise false.
+        /// </returns>
+        public bool Exists(IVisual layerRoot)
+        {
+            Contract.Requires<ArgumentNullException>(layerRoot != null);
+
+            return _index.ContainsKey(layerRoot);
+        }
+
+        /// <summary>
+        /// Tries to find a layer with the specified root visual.
+        /// </summary>
+        /// <param name="layerRoot">The root visual.</param>
+        /// <returns>The layer if found, otherwise null.</returns>
+        public SceneLayer Find(IVisual layerRoot)
+        {
+            SceneLayer result;
+            _index.TryGetValue(layerRoot, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Gets an existing layer or creates a new one if no existing layer is found.
+        /// </summary>
+        /// <param name="layerRoot">The root visual.</param>
+        /// <returns>The layer.</returns>
+        public SceneLayer GetOrAdd(IVisual layerRoot)
+        {
+            Contract.Requires<ArgumentNullException>(layerRoot != null);
+
+            SceneLayer result;
+
+            if (!_index.TryGetValue(layerRoot, out result))
+            {
+                result = Add(layerRoot);
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Removes a layer from the scene.
+        /// </summary>
+        /// <param name="layerRoot">The root visual.</param>
+        /// <returns>True if a matching layer was removed, otherwise false.</returns>
+        public bool Remove(IVisual layerRoot)
+        {
+            Contract.Requires<ArgumentNullException>(layerRoot != null);
+
+            SceneLayer layer;
+
+            if (_index.TryGetValue(layerRoot, out layer))
+            {
+                Remove(layer);
+            }
+
+            return layer != null;
+        }
+
+        /// <summary>
+        /// Removes a layer from the scene.
+        /// </summary>
+        /// <param name="layer">The layer.</param>
+        /// <returns>True if the layer was part of the scene, otherwise false.</returns>
+        public bool Remove(SceneLayer layer)
+        {
+            Contract.Requires<ArgumentNullException>(layer != null);
+
+            _index.Remove(layer.LayerRoot);
+            return _inner.Remove(layer);
+        }
+
+        /// <inheritdoc/>
+        public IEnumerator<SceneLayer> GetEnumerator() => _inner.GetEnumerator();
+
+        /// <inheritdoc/>
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        private int FindInsertIndex(SceneLayer insert)
+        {
+            var index = 0;
+
+            foreach (var layer in _inner)
+            {
+                if (layer.DistanceFromRoot > insert.DistanceFromRoot)
+                {
+                    break;
+                }
+
+                ++index;
+            }
+
+            return index;
+        }
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/TextNode.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/TextNode.cs
new file mode 100644
index 00000000000..058f3b1c221
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/TextNode.cs
@@ -0,0 +1,96 @@
+// Copyright (c) The Avalonia Project. All rights reserved.
+// Licensed under the MIT license. See licence.md file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using Avalonia.Media;
+using Avalonia.Platform;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Rendering.SceneGraph
+{
+    /// <summary>
+    /// A node in the scene graph which represents a text draw.
+    /// </summary>
+    internal class TextNode : BrushDrawOperation
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TextNode"/> class.
+        /// </summary>
+        /// <param name="transform">The transform.</param>
+        /// <param name="foreground">The foreground brush.</param>
+        /// <param name="origin">The draw origin.</param>
+        /// <param name="text">The text to draw.</param>
+        /// <param name="childScenes">Child scenes for drawing visual brushes.</param>
+        public TextNode(
+            Matrix transform,
+            IBrush foreground,
+            Point origin,
+            IFormattedTextImpl text,
+            IDictionary<IVisual, Scene> childScenes = null)
+        {
+            Bounds = new Rect(origin, text.Size).TransformToAABB(transform);
+            Transform = transform;
+            Foreground = foreground?.ToImmutable();
+            Origin = origin;
+            Text = text;
+            ChildScenes = childScenes;
+        }
+
+        /// <inheritdoc/>
+        public override Rect Bounds { get; }
+
+        /// <summary>
+        /// Gets the transform with which the node will be drawn.
+        /// </summary>
+        public Matrix Transform { get; }
+
+        /// <summary>
+        /// Gets the foreground brush.
+        /// </summary>
+        public IBrush Foreground { get; }
+
+        /// <summary>
+        /// Gets the draw origin.
+        /// </summary>
+        public Point Origin { get; }
+
+        /// <summary>
+        /// Gets the text to draw.
+        /// </summary>
+        public IFormattedTextImpl Text { get; }
+
+        /// <inheritdoc/>
+        public override IDictionary<IVisual, Scene> ChildScenes { get; }
+
+        /// <inheritdoc/>
+        public override void Render(IDrawingContextImpl context)
+        {
+            context.Transform = Transform;
+            context.DrawText(Foreground, Origin, Text);
+        }
+
+        /// <summary>
+        /// Determines if this draw operation equals another.
+        /// </summary>
+        /// <param name="transform">The transform of the other draw operation.</param>
+        /// <param name="foreground">The foregroundof the other draw operation.</param>
+        /// <param name="origin">The draw origin of the other draw operation.</param>
+        /// <param name="text">The text of the other draw operation.</param>
+        /// <returns>True if the draw operations are the same, otherwise false.</returns>
+        /// <remarks>
+        /// The properties of the other draw operation are passed in as arguments to prevent
+        /// allocation of a not-yet-constructed draw operation object.
+        /// </remarks>
+        internal bool Equals(Matrix transform, IBrush foreground, Point origin, IFormattedTextImpl text)
+        {
+            return transform == Transform &&
+                Equals(foreground, Foreground) &&
+                origin == Origin &&
+                Equals(text, Text);
+        }
+
+        /// <inheritdoc/>
+        public override bool HitTest(Point p) => Bounds.Contains(p);
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/VisualNode.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/VisualNode.cs
new file mode 100644
index 00000000000..dd5740e4a90
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/VisualNode.cs
@@ -0,0 +1,285 @@
+// Copyright (c) The Avalonia Project. All rights reserved.
+// Licensed under the MIT license. See licence.md file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using Avalonia.Media;
+using Avalonia.Platform;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Rendering.SceneGraph
+{
+    /// <summary>
+    /// A node in the low-level scene graph representing an <see cref="IVisual"/>.
+    /// </summary>
+    internal class VisualNode : IVisualNode
+    {
+        private static readonly IReadOnlyList<IVisualNode> EmptyChildren = new IVisualNode[0];
+        private static readonly IReadOnlyList<IDrawOperation> EmptyDrawOperations = new IDrawOperation[0];
+
+        private Rect? _bounds;
+        private double _opacity;
+        private List<IVisualNode> _children;
+        private List<IDrawOperation> _drawOperations;
+        private bool _drawOperationsCloned;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="VisualNode"/> class.
+        /// </summary>
+        /// <param name="visual">The visual that this node represents.</param>
+        /// <param name="parent">The parent scene graph node, if any.</param>
+        public VisualNode(IVisual visual, IVisualNode parent)
+        {
+            Contract.Requires<ArgumentNullException>(visual != null);
+
+            Visual = visual;
+            Parent = parent;
+            HasAncestorGeometryClip = parent != null && 
+                (parent.HasAncestorGeometryClip || parent.GeometryClip != null);
+        }
+
+        /// <inheritdoc/>
+        public IVisual Visual { get; }
+
+        /// <inheritdoc/>
+        public IVisualNode Parent { get; }
+
+        /// <inheritdoc/>
+        public Matrix Transform { get; set; }
+
+        /// <inheritdoc/>
+        public Rect Bounds => _bounds ?? CalculateBounds();
+
+        /// <inheritdoc/>
+        public Rect ClipBounds { get; set; }
+
+        /// <inheritdoc/>
+        public bool ClipToBounds { get; set; }
+
+        /// <inheritdoc/>
+        public IGeometryImpl GeometryClip { get; set; }
+
+        /// <inheritdoc/>
+        public bool HasAncestorGeometryClip { get; }
+
+        /// <summary>
+        /// Gets or sets the opacity of the scene graph node.
+        /// </summary>
+        public double Opacity
+        {
+            get { return _opacity; }
+            set
+            {
+                if (_opacity != value)
+                {
+                    _opacity = value;
+                    OpacityChanged = true;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the opacity mask for the scnee graph node.
+        /// </summary>
+        public IBrush OpacityMask { get; set; }
+
+        /// <summary>
+        /// Gets a value indicating whether this node in the scene graph has already
+        /// been updated in the current update pass.
+        /// </summary>
+        public bool SubTreeUpdated { get; set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the <see cref="Opacity"/> property has changed.
+        /// </summary>
+        public bool OpacityChanged { get; private set; }
+
+        public IVisual LayerRoot { get; set; }
+
+        /// <inheritdoc/>
+        public IReadOnlyList<IVisualNode> Children => _children ?? EmptyChildren;
+
+        /// <inheritdoc/>
+        public IReadOnlyList<IDrawOperation> DrawOperations => _drawOperations ?? EmptyDrawOperations;
+
+        /// <summary>
+        /// Adds a child to the <see cref="Children"/> collection.
+        /// </summary>
+        /// <param name="child">The child to add.</param>
+        public void AddChild(IVisualNode child)
+        {
+            EnsureChildrenCreated();
+            _children.Add(child);
+        }
+
+        /// <summary>
+        /// Adds an operation to the <see cref="DrawOperations"/> collection.
+        /// </summary>
+        /// <param name="operation">The operation to add.</param>
+        public void AddDrawOperation(IDrawOperation operation)
+        {
+            EnsureDrawOperationsCreated();
+            _drawOperations.Add(operation);
+        }
+
+        /// <summary>
+        /// Removes a child from the <see cref="Children"/> collection.
+        /// </summary>
+        /// <param name="child">The child to remove.</param>
+        public void RemoveChild(IVisualNode child)
+        {
+            EnsureChildrenCreated();
+            _children.Remove(child);
+        }
+
+        /// <summary>
+        /// Replaces a child in the <see cref="Children"/> collection.
+        /// </summary>
+        /// <param name="index">The child to be replaced.</param>
+        /// <param name="node">The child to add.</param>
+        public void ReplaceChild(int index, IVisualNode node)
+        {
+            EnsureChildrenCreated();
+            _children[index] = node;
+        }
+
+        /// <summary>
+        /// Replaces an item in the <see cref="DrawOperations"/> collection.
+        /// </summary>
+        /// <param name="index">The opeation to be replaced.</param>
+        /// <param name="operation">The operation to add.</param>
+        public void ReplaceDrawOperation(int index, IDrawOperation operation)
+        {
+            EnsureDrawOperationsCreated();
+            _drawOperations[index] = operation;
+        }
+
+        /// <summary>
+        /// Removes items in the <see cref="Children"/> collection from the specified index
+        /// to the end.
+        /// </summary>
+        /// <param name="first">The index of the first child to be removed.</param>
+        public void TrimChildren(int first)
+        {
+            if (first < _children?.Count)
+            {
+                EnsureChildrenCreated();
+                _children.RemoveRange(first, _children.Count - first);
+            }
+        }
+
+        /// <summary>
+        /// Removes items in the <see cref="DrawOperations"/> collection from the specified index
+        /// to the end.
+        /// </summary>
+        /// <param name="first">The index of the first operation to be removed.</param>
+        public void TrimDrawOperations(int first)
+        {
+            if (first < _drawOperations?.Count)
+            {
+                EnsureDrawOperationsCreated();
+                _drawOperations.RemoveRange(first, _drawOperations.Count - first);
+            }
+        }
+
+        /// <summary>
+        /// Makes a copy of the node
+        /// </summary>
+        /// <param name="parent">The new parent node.</param>
+        /// <returns>A cloned node.</returns>
+        public VisualNode Clone(IVisualNode parent)
+        {
+            return new VisualNode(Visual, parent)
+            {
+                Transform = Transform,
+                ClipBounds = ClipBounds,
+                ClipToBounds = ClipToBounds,
+                GeometryClip = GeometryClip,
+                _opacity = Opacity,
+                OpacityMask = OpacityMask,
+                _drawOperations = _drawOperations,
+                _drawOperationsCloned = true,
+                LayerRoot= LayerRoot,
+            };
+        }
+
+        /// <inheritdoc/>
+        public bool HitTest(Point p)
+        {
+            foreach (var operation in DrawOperations)
+            {
+                if (operation.HitTest(p) == true)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <inheritdoc/>
+        public void BeginRender(IDrawingContextImpl context)
+        {
+            if (ClipToBounds)
+            {
+                context.Transform = Matrix.Identity;
+                context.PushClip(ClipBounds);
+            }
+
+            context.Transform = Transform;
+
+            if (GeometryClip != null)
+            {
+                context.PushGeometryClip(GeometryClip);
+            }
+        }
+
+        /// <inheritdoc/>
+        public void EndRender(IDrawingContextImpl context)
+        {
+            if (GeometryClip != null)
+            {
+                context.PopGeometryClip();
+            }
+
+            if (ClipToBounds)
+            {
+                context.PopClip();
+            }
+        }
+
+        private Rect CalculateBounds()
+        {
+            var result = new Rect();
+
+            foreach (var operation in DrawOperations)
+            {
+                result = result.Union(operation.Bounds);
+            }
+
+            _bounds = result;
+            return result;
+        }
+
+        private void EnsureChildrenCreated()
+        {
+            if (_children == null)
+            {
+                _children = new List<IVisualNode>();
+            }
+        }
+
+        private void EnsureDrawOperationsCreated()
+        {
+            if (_drawOperations == null)
+            {
+                _drawOperations = new List<IDrawOperation>();
+            }
+            else if (_drawOperationsCloned)
+            {
+                _drawOperations = new List<IDrawOperation>(_drawOperations);
+                _drawOperationsCloned = false;
+            }
+        }
+    }
+}
diff --git a/src/Avalonia.Visuals/Vector.cs b/src/Avalonia.Visuals/Vector.cs
index 69cbfd95928..c4545b8e5c3 100644
--- a/src/Avalonia.Visuals/Vector.cs
+++ b/src/Avalonia.Visuals/Vector.cs
@@ -74,6 +74,17 @@ public static explicit operator Point(Vector a)
             return new Vector(vector._x * scale, vector._y * scale);
         }
 
+        /// <summary>
+        /// Scales a vector.
+        /// </summary>
+        /// <param name="vector">The vector</param>
+        /// <param name="scale">The divisor.</param>
+        /// <returns>The scaled vector.</returns>
+        public static Vector operator /(Vector vector, double scale)
+        {
+            return new Vector(vector._x / scale, vector._y / scale);
+        }
+
         /// <summary>
         /// Length of the vector
         /// </summary>
diff --git a/src/Avalonia.Visuals/VisualTree/VisualExtensions.cs b/src/Avalonia.Visuals/VisualTree/VisualExtensions.cs
index 289c4134d18..4f4bf4b9fe6 100644
--- a/src/Avalonia.Visuals/VisualTree/VisualExtensions.cs
+++ b/src/Avalonia.Visuals/VisualTree/VisualExtensions.cs
@@ -13,6 +13,30 @@ namespace Avalonia.VisualTree
     /// </summary>
     public static class VisualExtensions
     {
+        /// <summary>
+        /// Calculates the distance from a visual's <see cref="IRenderRoot"/>.
+        /// </summary>
+        /// <param name="visual">The visual.</param>
+        /// <param name="ancestor">The ancestor visual.</param>
+        /// <returns>
+        /// The number of steps from the visual to the ancestor or -1 if
+        /// <paramref name="visual"/> is not a descendent of <paramref name="ancestor"/>.
+        /// </returns>
+        public static int CalculateDistanceFromAncestor(this IVisual visual, IVisual ancestor)
+        {
+            Contract.Requires<ArgumentNullException>(visual != null);
+
+            var result = 0;
+
+            while (visual != null && visual != ancestor)
+            {
+                ++result;
+                visual = visual.VisualParent;
+            }
+
+            return visual != null ? result : -1;
+        }
+
         /// <summary>
         /// Tries to get the first common ancestor of two visuals.
         /// </summary>
diff --git a/src/Gtk/Avalonia.Cairo/Avalonia.Cairo.v2.ncrunchproject b/src/Gtk/Avalonia.Cairo/Avalonia.Cairo.v2.ncrunchproject
deleted file mode 100644
index 30815b1937d..00000000000
--- a/src/Gtk/Avalonia.Cairo/Avalonia.Cairo.v2.ncrunchproject
+++ /dev/null
@@ -1,26 +0,0 @@
-<ProjectConfiguration>
-  <AutoDetectNugetBuildDependencies>true</AutoDetectNugetBuildDependencies>
-  <BuildPriority>1000</BuildPriority>
-  <CopyReferencedAssembliesToWorkspace>false</CopyReferencedAssembliesToWorkspace>
-  <ConsiderInconclusiveTestsAsPassing>false</ConsiderInconclusiveTestsAsPassing>
-  <PreloadReferencedAssemblies>false</PreloadReferencedAssemblies>
-  <AllowDynamicCodeContractChecking>true</AllowDynamicCodeContractChecking>
-  <AllowStaticCodeContractChecking>false</AllowStaticCodeContractChecking>
-  <AllowCodeAnalysis>false</AllowCodeAnalysis>
-  <IgnoreThisComponentCompletely>false</IgnoreThisComponentCompletely>
-  <RunPreBuildEvents>false</RunPreBuildEvents>
-  <RunPostBuildEvents>false</RunPostBuildEvents>
-  <PreviouslyBuiltSuccessfully>true</PreviouslyBuiltSuccessfully>
-  <InstrumentAssembly>true</InstrumentAssembly>
-  <PreventSigningOfAssembly>false</PreventSigningOfAssembly>
-  <AnalyseExecutionTimes>true</AnalyseExecutionTimes>
-  <DetectStackOverflow>true</DetectStackOverflow>
-  <IncludeStaticReferencesInWorkspace>true</IncludeStaticReferencesInWorkspace>
-  <DefaultTestTimeout>60000</DefaultTestTimeout>
-  <UseBuildConfiguration />
-  <UseBuildPlatform />
-  <ProxyProcessPath />
-  <UseCPUArchitecture>AutoDetect</UseCPUArchitecture>
-  <MSTestThreadApartmentState>STA</MSTestThreadApartmentState>
-  <BuildProcessArchitecture>x86</BuildProcessArchitecture>
-</ProjectConfiguration>
\ No newline at end of file
diff --git a/src/Gtk/Avalonia.Cairo/CairoPlatform.cs b/src/Gtk/Avalonia.Cairo/CairoPlatform.cs
index 8a68d58e201..e3578874a3d 100644
--- a/src/Gtk/Avalonia.Cairo/CairoPlatform.cs
+++ b/src/Gtk/Avalonia.Cairo/CairoPlatform.cs
@@ -26,6 +26,7 @@ namespace Avalonia.Cairo
 {
     using System.IO;
     using global::Cairo;
+    using Rendering;
 
     public class CairoPlatform : IPlatformRenderInterface
     {
diff --git a/src/Gtk/Avalonia.Cairo/Media/RadialGradientBrushImpl.cs b/src/Gtk/Avalonia.Cairo/Media/RadialGradientBrushImpl.cs
index 52460c96281..03385f8d865 100644
--- a/src/Gtk/Avalonia.Cairo/Media/RadialGradientBrushImpl.cs
+++ b/src/Gtk/Avalonia.Cairo/Media/RadialGradientBrushImpl.cs
@@ -10,9 +10,10 @@ public RadialGradientBrushImpl(IRadialGradientBrush brush, Size destinationSize)
 		{
 			var center = brush.Center.ToPixels(destinationSize);
 			var gradientOrigin = brush.GradientOrigin.ToPixels(destinationSize);
-            var radius = brush.Radius;
+            var radius = brush.Radius * Math.Min(destinationSize.Width, destinationSize.Height);
 
-			this.PlatformBrush = new RadialGradient(center.X, center.Y, radius, gradientOrigin.X, gradientOrigin.Y, radius);
+            this.PlatformBrush = new RadialGradient(center.X, center.Y, 1, gradientOrigin.X, gradientOrigin.Y, radius);
+            this.PlatformBrush.Matrix = Matrix.Identity.ToCairo();
 
             foreach (var stop in brush.GradientStops)
             {
diff --git a/src/Gtk/Avalonia.Gtk/GtkPlatform.cs b/src/Gtk/Avalonia.Gtk/GtkPlatform.cs
index ef7e4d3362c..f449229c539 100644
--- a/src/Gtk/Avalonia.Gtk/GtkPlatform.cs
+++ b/src/Gtk/Avalonia.Gtk/GtkPlatform.cs
@@ -28,7 +28,7 @@ namespace Avalonia.Gtk
     using Rendering;
     using Gtk = global::Gtk;
 
-    public class GtkPlatform : IPlatformThreadingInterface, IPlatformSettings, IWindowingPlatform, IPlatformIconLoader, IRendererFactory
+    public class GtkPlatform : IPlatformThreadingInterface, IPlatformSettings, IWindowingPlatform, IPlatformIconLoader
     {
         private static readonly GtkPlatform s_instance = new GtkPlatform();
         private static Thread _uiThread;
@@ -53,7 +53,6 @@ public static void Initialize()
                 .Bind<IKeyboardDevice>().ToConstant(GtkKeyboardDevice.Instance)
                 .Bind<IPlatformSettings>().ToConstant(s_instance)
                 .Bind<IPlatformThreadingInterface>().ToConstant(s_instance)
-                .Bind<IRendererFactory>().ToConstant(s_instance)
                 .Bind<IRenderLoop>().ToConstant(new DefaultRenderLoop(60))
                 .Bind<ISystemDialogImpl>().ToSingleton<SystemDialogImpl>()
                 .Bind<IPlatformIconLoader>().ToConstant(s_instance);
@@ -112,11 +111,6 @@ public IPopupImpl CreatePopup()
             return new PopupImpl();
         }
 
-        public IRenderer CreateRenderer(IRenderRoot root, IRenderLoop renderLoop)
-        {
-            return new ImmediateRenderer(root);
-        }
-
         public IWindowIconImpl LoadIcon(string fileName)
         {
             return new IconImpl(new Gdk.Pixbuf(fileName));
diff --git a/src/Gtk/Avalonia.Gtk/TopLevelImpl.cs b/src/Gtk/Avalonia.Gtk/TopLevelImpl.cs
index ce1f50ac0f9..5c18d015d4b 100644
--- a/src/Gtk/Avalonia.Gtk/TopLevelImpl.cs
+++ b/src/Gtk/Avalonia.Gtk/TopLevelImpl.cs
@@ -10,6 +10,7 @@
 using Action = System.Action;
 using WindowEdge = Avalonia.Controls.WindowEdge;
 using GLib;
+using Avalonia.Rendering;
 
 namespace Avalonia.Gtk
 {
@@ -141,6 +142,11 @@ public IPopupImpl CreatePopup()
             return new PopupImpl();
         }
 
+        public IRenderer CreateRenderer(IRenderRoot root)
+        {
+            return new ImmediateRenderer(root);
+        }
+
         public void Invalidate(Rect rect)
         {
             if (_widget?.GdkWindow != null)
diff --git a/src/Gtk/Avalonia.Gtk3/Gtk3Platform.cs b/src/Gtk/Avalonia.Gtk3/Gtk3Platform.cs
index a3db0def74f..4ea1a5af56b 100644
--- a/src/Gtk/Avalonia.Gtk3/Gtk3Platform.cs
+++ b/src/Gtk/Avalonia.Gtk3/Gtk3Platform.cs
@@ -15,7 +15,7 @@
 
 namespace Avalonia.Gtk3
 {
-    public class Gtk3Platform : IWindowingPlatform, IPlatformSettings, IPlatformThreadingInterface, IRendererFactory
+    public class Gtk3Platform : IWindowingPlatform, IPlatformSettings, IPlatformThreadingInterface
     {
         internal static readonly Gtk3Platform Instance = new Gtk3Platform();
         internal static readonly MouseDevice Mouse = new MouseDevice();
@@ -38,7 +38,6 @@ public static void Initialize()
                 .Bind<IPlatformThreadingInterface>().ToConstant(Instance)
                 .Bind<ISystemDialogImpl>().ToSingleton<SystemDialog>()
                 .Bind<IRenderLoop>().ToConstant(new DefaultRenderLoop(60))
-                .Bind<IRendererFactory>().ToConstant(ImmediateRenderer.Factory)
                 .Bind<IPlatformIconLoader>().ToConstant(new PlatformIconLoader());
 
         }
@@ -52,11 +51,6 @@ public IEmbeddableWindowImpl CreateEmbeddableWindow()
 
         public IPopupImpl CreatePopup() => new PopupImpl();
 
-        public IRenderer CreateRenderer(IRenderRoot root, IRenderLoop renderLoop)
-        {
-            return new ImmediateRenderer(root);
-        }
-
         public Size DoubleClickSize => new Size(4, 4);
 
         public TimeSpan DoubleClickTime => TimeSpan.FromMilliseconds(100); //STUB
diff --git a/src/Gtk/Avalonia.Gtk3/WindowBaseImpl.cs b/src/Gtk/Avalonia.Gtk3/WindowBaseImpl.cs
index 39304940d21..4464059efb9 100644
--- a/src/Gtk/Avalonia.Gtk3/WindowBaseImpl.cs
+++ b/src/Gtk/Avalonia.Gtk3/WindowBaseImpl.cs
@@ -9,6 +9,7 @@
 using Avalonia.Input;
 using Avalonia.Input.Raw;
 using Avalonia.Platform;
+using Avalonia.Rendering;
 
 namespace Avalonia.Gtk3
 {
@@ -354,5 +355,10 @@ public Point Position
 
         IntPtr IPlatformHandle.Handle => Native.GetNativeGdkWindowHandle(Native.GtkWidgetGetWindow(GtkWidget));
         public IEnumerable<object> Surfaces => new object[] {Handle, _framebuffer};
+
+        public IRenderer CreateRenderer(IRenderRoot root)
+        {
+            return new ImmediateRenderer(root);
+        }
     }
 }
diff --git a/src/Linux/Avalonia.LinuxFramebuffer/FramebufferToplevelImpl.cs b/src/Linux/Avalonia.LinuxFramebuffer/FramebufferToplevelImpl.cs
index 0854f9acf4a..daff4dd7516 100644
--- a/src/Linux/Avalonia.LinuxFramebuffer/FramebufferToplevelImpl.cs
+++ b/src/Linux/Avalonia.LinuxFramebuffer/FramebufferToplevelImpl.cs
@@ -5,6 +5,7 @@
 using Avalonia.Input;
 using Avalonia.Input.Raw;
 using Avalonia.Platform;
+using Avalonia.Rendering;
 using Avalonia.Threading;
 
 namespace Avalonia.LinuxFramebuffer
@@ -24,6 +25,11 @@ public FramebufferToplevelImpl(LinuxFramebuffer fb)
             mice.Event += e => Input?.Invoke(e);
         }
 
+        public IRenderer CreateRenderer(IRenderRoot root)
+        {
+            return new ImmediateRenderer(root);
+        }
+
         public void Dispose()
         {
             throw new NotSupportedException();
diff --git a/src/Linux/Avalonia.LinuxFramebuffer/LinuxFramebufferPlatform.cs b/src/Linux/Avalonia.LinuxFramebuffer/LinuxFramebufferPlatform.cs
index 5f1c55fd5db..6db153c3e07 100644
--- a/src/Linux/Avalonia.LinuxFramebuffer/LinuxFramebufferPlatform.cs
+++ b/src/Linux/Avalonia.LinuxFramebuffer/LinuxFramebufferPlatform.cs
@@ -34,7 +34,6 @@ void Initialize()
                 .Bind<IStandardCursorFactory>().ToTransient<CursorFactoryStub>()
                 .Bind<IKeyboardDevice>().ToConstant(KeyboardDevice)
                 .Bind<IPlatformSettings>().ToSingleton<PlatformSettings>()
-                .Bind<IRendererFactory>().ToConstant(ImmediateRenderer.Factory)
                 .Bind<IPlatformThreadingInterface>().ToConstant(PlatformThreadingInterface.Instance)
                 .Bind<IRenderLoop>().ToConstant(PlatformThreadingInterface.Instance);
         }
diff --git a/src/Shared/SharedAssemblyInfo.cs b/src/Shared/SharedAssemblyInfo.cs
index 81c31e2687b..7d4061eb236 100644
--- a/src/Shared/SharedAssemblyInfo.cs
+++ b/src/Shared/SharedAssemblyInfo.cs
@@ -3,6 +3,7 @@
 
 using System.Reflection;
 using System.Resources;
+using System.Runtime.CompilerServices;
 
 [assembly: AssemblyCompany("")]
 [assembly: AssemblyConfiguration("")]
diff --git a/src/Skia/Avalonia.Skia.Android/Avalonia.Skia.Android.v2.ncrunchproject b/src/Skia/Avalonia.Skia.Android/Avalonia.Skia.Android.v2.ncrunchproject
deleted file mode 100644
index 30815b1937d..00000000000
--- a/src/Skia/Avalonia.Skia.Android/Avalonia.Skia.Android.v2.ncrunchproject
+++ /dev/null
@@ -1,26 +0,0 @@
-<ProjectConfiguration>
-  <AutoDetectNugetBuildDependencies>true</AutoDetectNugetBuildDependencies>
-  <BuildPriority>1000</BuildPriority>
-  <CopyReferencedAssembliesToWorkspace>false</CopyReferencedAssembliesToWorkspace>
-  <ConsiderInconclusiveTestsAsPassing>false</ConsiderInconclusiveTestsAsPassing>
-  <PreloadReferencedAssemblies>false</PreloadReferencedAssemblies>
-  <AllowDynamicCodeContractChecking>true</AllowDynamicCodeContractChecking>
-  <AllowStaticCodeContractChecking>false</AllowStaticCodeContractChecking>
-  <AllowCodeAnalysis>false</AllowCodeAnalysis>
-  <IgnoreThisComponentCompletely>false</IgnoreThisComponentCompletely>
-  <RunPreBuildEvents>false</RunPreBuildEvents>
-  <RunPostBuildEvents>false</RunPostBuildEvents>
-  <PreviouslyBuiltSuccessfully>true</PreviouslyBuiltSuccessfully>
-  <InstrumentAssembly>true</InstrumentAssembly>
-  <PreventSigningOfAssembly>false</PreventSigningOfAssembly>
-  <AnalyseExecutionTimes>true</AnalyseExecutionTimes>
-  <DetectStackOverflow>true</DetectStackOverflow>
-  <IncludeStaticReferencesInWorkspace>true</IncludeStaticReferencesInWorkspace>
-  <DefaultTestTimeout>60000</DefaultTestTimeout>
-  <UseBuildConfiguration />
-  <UseBuildPlatform />
-  <ProxyProcessPath />
-  <UseCPUArchitecture>AutoDetect</UseCPUArchitecture>
-  <MSTestThreadApartmentState>STA</MSTestThreadApartmentState>
-  <BuildProcessArchitecture>x86</BuildProcessArchitecture>
-</ProjectConfiguration>
\ No newline at end of file
diff --git a/src/Skia/Avalonia.Skia.Desktop/Avalonia.Skia.Desktop.v2.ncrunchproject b/src/Skia/Avalonia.Skia.Desktop/Avalonia.Skia.Desktop.v2.ncrunchproject
deleted file mode 100644
index e1b4d7cf284..00000000000
--- a/src/Skia/Avalonia.Skia.Desktop/Avalonia.Skia.Desktop.v2.ncrunchproject
+++ /dev/null
@@ -1,26 +0,0 @@
-<ProjectConfiguration>
-  <AutoDetectNugetBuildDependencies>true</AutoDetectNugetBuildDependencies>
-  <BuildPriority>1000</BuildPriority>
-  <CopyReferencedAssembliesToWorkspace>false</CopyReferencedAssembliesToWorkspace>
-  <ConsiderInconclusiveTestsAsPassing>false</ConsiderInconclusiveTestsAsPassing>
-  <PreloadReferencedAssemblies>false</PreloadReferencedAssemblies>
-  <AllowDynamicCodeContractChecking>true</AllowDynamicCodeContractChecking>
-  <AllowStaticCodeContractChecking>false</AllowStaticCodeContractChecking>
-  <AllowCodeAnalysis>false</AllowCodeAnalysis>
-  <IgnoreThisComponentCompletely>true</IgnoreThisComponentCompletely>
-  <RunPreBuildEvents>false</RunPreBuildEvents>
-  <RunPostBuildEvents>false</RunPostBuildEvents>
-  <PreviouslyBuiltSuccessfully>false</PreviouslyBuiltSuccessfully>
-  <InstrumentAssembly>true</InstrumentAssembly>
-  <PreventSigningOfAssembly>false</PreventSigningOfAssembly>
-  <AnalyseExecutionTimes>true</AnalyseExecutionTimes>
-  <DetectStackOverflow>true</DetectStackOverflow>
-  <IncludeStaticReferencesInWorkspace>true</IncludeStaticReferencesInWorkspace>
-  <DefaultTestTimeout>60000</DefaultTestTimeout>
-  <UseBuildConfiguration />
-  <UseBuildPlatform />
-  <ProxyProcessPath />
-  <UseCPUArchitecture>AutoDetect</UseCPUArchitecture>
-  <MSTestThreadApartmentState>STA</MSTestThreadApartmentState>
-  <BuildProcessArchitecture>x86</BuildProcessArchitecture>
-</ProjectConfiguration>
\ No newline at end of file
diff --git a/src/Skia/Avalonia.Skia.Desktop/RenderTarget.cs b/src/Skia/Avalonia.Skia.Desktop/RenderTarget.cs
deleted file mode 100644
index ef5fb88142b..00000000000
--- a/src/Skia/Avalonia.Skia.Desktop/RenderTarget.cs
+++ /dev/null
@@ -1,172 +0,0 @@
-using System;
-using Avalonia.Media;
-using Avalonia.Platform;
-using SkiaSharp;
-#if WIN32
-using Avalonia.Win32.Interop;
-#endif
-
-namespace Avalonia.Skia
-{
-    internal partial class RenderTarget : IRenderTarget
-    {
-        public SKSurface Surface { get; protected set; }
-
-        public virtual DrawingContext CreateDrawingContext()
-        {
-            return
-                new DrawingContext(
-                    new DrawingContextImpl(Surface.Canvas));
-        }
-
-        public void Dispose()
-        {
-            // Nothing to do here.
-        }
-    }
-
-    internal class WindowRenderTarget : RenderTarget
-    {
-        private readonly IPlatformHandle _hwnd;
-        SKBitmap _bitmap;
-        int Width { get; set; }
-        int Height { get; set; }
-
-        public WindowRenderTarget(IPlatformHandle hwnd)
-        {
-            _hwnd = hwnd;
-            FixSize();
-        }
-
-        private void FixSize()
-        {
-            int width, height;
-            GetPlatformWindowSize(out width, out height);
-            if (Width == width && Height == height)
-                return;
-
-            Width = width;
-            Height = height;
-
-            if (Surface != null)
-            {
-                Surface.Dispose();
-            }
-
-            if (_bitmap != null)
-            {
-                _bitmap.Dispose();
-            }
-
-            _bitmap = new SKBitmap(width, height, SKImageInfo.PlatformColorType, SKAlphaType.Premul);
-
-            IntPtr length;
-            var pixels = _bitmap.GetPixels(out length);
-
-            // Wrap the bitmap in a Surface and keep it cached
-            Surface = SKSurface.Create(_bitmap.Info, pixels, _bitmap.RowBytes);
-        }
-
-        private void GetPlatformWindowSize(out int w, out int h)
-        {
-#if WIN32
-            UnmanagedMethods.RECT rc;
-            UnmanagedMethods.GetClientRect(_hwnd.Handle, out rc);
-            w = rc.right - rc.left;
-            h = rc.bottom - rc.top;
-#else
-			throw new NotImplementedException();
-#endif
-        }
-
-        private Size GetWindowDpiWin32()
-        {
-            if (UnmanagedMethods.ShCoreAvailable)
-            {
-                uint dpix, dpiy;
-
-                var monitor = UnmanagedMethods.MonitorFromWindow(
-                    _hwnd.Handle,
-                    UnmanagedMethods.MONITOR.MONITOR_DEFAULTTONEAREST);
-
-                if (UnmanagedMethods.GetDpiForMonitor(
-                        monitor,
-                        UnmanagedMethods.MONITOR_DPI_TYPE.MDT_EFFECTIVE_DPI,
-                        out dpix,
-                        out dpiy) == 0)
-                {
-                    return new Size(dpix, dpiy);
-                }
-            }
-
-            return new Size(96, 96);
-        }
-
-        public override DrawingContext CreateDrawingContext()
-        {
-            FixSize();
-
-            var canvas = Surface.Canvas;
-            canvas.RestoreToCount(0);
-            canvas.Save();
-            canvas.Clear(SKColors.Red);
-            canvas.ResetMatrix();
-
-            double scale = 1.0;
-
-            var runtimeService = AvaloniaLocator.Current.GetService<IRuntimePlatform>();
-
-            if (runtimeService != null)
-            {
-                switch (runtimeService.GetRuntimeInfo().OperatingSystem)
-                {
-                    case OperatingSystemType.WinNT:
-                        var dpi = GetWindowDpiWin32();
-                        scale = dpi.Width / 96.0;
-                        break;
-                }
-            }
-
-            var result =
-                new DrawingContext(
-                    new WindowDrawingContextImpl(this), Matrix.CreateScale(scale, scale));
-            
-            return result;
-        }
-
-        public void Present()
-        {
-            _bitmap.LockPixels();
-            IntPtr length;
-            var pixels = _bitmap.GetPixels(out length);
-
-#if WIN32
-            UnmanagedMethods.BITMAPINFO bmi = new UnmanagedMethods.BITMAPINFO();
-            bmi.biSize = UnmanagedMethods.SizeOf_BITMAPINFOHEADER;
-            bmi.biWidth = _bitmap.Width;
-            bmi.biHeight = -_bitmap.Height; // top-down image
-            bmi.biPlanes = 1;
-            bmi.biBitCount = 32;
-            bmi.biCompression = (uint)UnmanagedMethods.BitmapCompressionMode.BI_RGB;
-            bmi.biSizeImage = 0;
-
-            IntPtr hdc = UnmanagedMethods.GetDC(_hwnd.Handle);
-
-            int ret = UnmanagedMethods.SetDIBitsToDevice(hdc,
-                0, 0,
-                (uint)_bitmap.Width, (uint)_bitmap.Height,
-                0, 0,
-                0, (uint)_bitmap.Height,
-                pixels,
-                ref bmi,
-                (uint)UnmanagedMethods.DIBColorTable.DIB_RGB_COLORS);
-
-            UnmanagedMethods.ReleaseDC(_hwnd.Handle, hdc);
-#else
-            throw new NotImplementedException();
-#endif
-
-            _bitmap.UnlockPixels();
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/Skia/Avalonia.Skia/BitmapImpl.cs b/src/Skia/Avalonia.Skia/BitmapImpl.cs
index e5e8faec5fc..8fd648be62c 100644
--- a/src/Skia/Avalonia.Skia/BitmapImpl.cs
+++ b/src/Skia/Avalonia.Skia/BitmapImpl.cs
@@ -1,9 +1,5 @@
 using System;
-using System.Collections.Generic;
 using System.IO;
-using System.Runtime.InteropServices;
-using System.Text;
-using Avalonia.Media;
 using Avalonia.Platform;
 using Avalonia.Rendering;
 using SkiaSharp;
@@ -12,6 +8,8 @@ namespace Avalonia.Skia
 {
     class BitmapImpl : IRenderTargetBitmapImpl, IWritableBitmapImpl
     {
+        private Vector _dpi;
+
         public SKBitmap Bitmap { get; private set; }
 
         public BitmapImpl(SKBitmap bm)
@@ -19,12 +17,14 @@ public BitmapImpl(SKBitmap bm)
             Bitmap = bm;
             PixelHeight = bm.Height;
             PixelWidth = bm.Width;
+            _dpi = new Vector(96, 96);
         }
 
-        public BitmapImpl(int width, int height, PixelFormat? fmt = null)
+        public BitmapImpl(int width, int height, Vector dpi, PixelFormat? fmt = null)
         {
             PixelHeight = height;
             PixelWidth = width;
+            _dpi = dpi;
             var colorType = fmt?.ToSkColorType() ?? SKImageInfo.PlatformColorType;
             var runtime = AvaloniaLocator.Current?.GetService<IRuntimePlatform>()?.GetRuntimeInfo();
             if (runtime?.IsDesktop == true && runtime?.OperatingSystem == OperatingSystemType.Linux)
@@ -68,8 +68,8 @@ class BitmapDrawingContext : DrawingContextImpl
         {
             private readonly SKSurface _surface;
 
-            public BitmapDrawingContext(SKBitmap bitmap, IVisualBrushRenderer visualBrushRenderer)
-                : this(CreateSurface(bitmap), visualBrushRenderer)
+            public BitmapDrawingContext(SKBitmap bitmap, Vector dpi, IVisualBrushRenderer visualBrushRenderer)
+                : this(CreateSurface(bitmap), dpi, visualBrushRenderer)
             {
 
             }
@@ -83,8 +83,8 @@ private static SKSurface CreateSurface(SKBitmap bitmap)
                 return rv;
             }
 
-            public BitmapDrawingContext(SKSurface surface, IVisualBrushRenderer visualBrushRenderer)
-                : base(surface.Canvas, visualBrushRenderer)
+            public BitmapDrawingContext(SKSurface surface, Vector dpi, IVisualBrushRenderer visualBrushRenderer)
+                : base(surface.Canvas, dpi, visualBrushRenderer)
             {
                 _surface = surface;
             }
@@ -98,7 +98,7 @@ public override void Dispose()
 
         public IDrawingContextImpl CreateDrawingContext(IVisualBrushRenderer visualBrushRenderer)
         {
-            return new BitmapDrawingContext(Bitmap, visualBrushRenderer);
+            return new BitmapDrawingContext(Bitmap, _dpi, visualBrushRenderer);
         }
 
         public void Save(Stream stream)
diff --git a/src/Skia/Avalonia.Skia/DrawingContextImpl.cs b/src/Skia/Avalonia.Skia/DrawingContextImpl.cs
index 3ed0509c0a6..7a83835b100 100644
--- a/src/Skia/Avalonia.Skia/DrawingContextImpl.cs
+++ b/src/Skia/Avalonia.Skia/DrawingContextImpl.cs
@@ -11,6 +11,7 @@ namespace Avalonia.Skia
 {
     internal class DrawingContextImpl : IDrawingContextImpl
     {
+        private readonly Vector _dpi;
         private readonly Matrix? _postTransform;
         private readonly IDisposable[] _disposables;
         private readonly IVisualBrushRenderer _visualBrushRenderer;
@@ -20,12 +21,13 @@ internal class DrawingContextImpl : IDrawingContextImpl
 
         public DrawingContextImpl(
             SKCanvas canvas,
+            Vector dpi,
             IVisualBrushRenderer visualBrushRenderer,
-            Matrix? postTransform = null,
             params IDisposable[] disposables)
         {
-            if (postTransform.HasValue && !postTransform.Value.IsIdentity)
-                _postTransform = postTransform;
+            _dpi = dpi;
+            if (dpi.X != 96 || dpi.Y != 96)
+                _postTransform = Matrix.CreateScale(dpi.X / 96, dpi.Y / 96);
             _visualBrushRenderer = visualBrushRenderer;
             _disposables = disposables;
             Canvas = canvas;
@@ -49,6 +51,13 @@ public void DrawImage(IBitmapImpl source, double opacity, Rect sourceRect, Rect
             }
         }
 
+        public void DrawImage(IBitmapImpl source, IBrush opacityMask, Rect opacityMaskRect, Rect destRect)
+        {
+            PushOpacityMask(opacityMask, opacityMaskRect);
+            DrawImage(source, 1, new Rect(0, 0, source.PixelWidth, source.PixelHeight), destRect);
+            PopOpacityMask();
+        }
+
         public void DrawLine(Pen pen, Point p1, Point p2)
         {
             using (var paint = CreatePaint(pen, new Size(Math.Abs(p2.X - p1.X), Math.Abs(p2.Y - p1.Y))))
@@ -204,7 +213,7 @@ internal PaintWrapper CreatePaint(IBrush brush, Size targetSize)
 
                     if (intermediateSize.Width >= 1 && intermediateSize.Height >= 1)
                     {
-                        var intermediate = new BitmapImpl((int)intermediateSize.Width, (int)intermediateSize.Height);
+                        var intermediate = new BitmapImpl((int)intermediateSize.Width, (int)intermediateSize.Height, _dpi);
 
                         using (var ctx = intermediate.CreateDrawingContext(_visualBrushRenderer))
                         {
@@ -229,7 +238,7 @@ internal PaintWrapper CreatePaint(IBrush brush, Size targetSize)
             if (tileBrush != null && tileBrushImage != null)
             {
                 var calc = new TileBrushCalculator(tileBrush, new Size(tileBrushImage.PixelWidth, tileBrushImage.PixelHeight), targetSize);
-                var bitmap = new BitmapImpl((int)calc.IntermediateSize.Width, (int)calc.IntermediateSize.Height);
+                var bitmap = new BitmapImpl((int)calc.IntermediateSize.Width, (int)calc.IntermediateSize.Height, _dpi);
                 rv.AddDisposable(bitmap);
                 using (var context = bitmap.CreateDrawingContext(null))
                 {
diff --git a/src/Skia/Avalonia.Skia/FormattedTextImpl.cs b/src/Skia/Avalonia.Skia/FormattedTextImpl.cs
index 1d224f97d75..c73e1dbcbed 100644
--- a/src/Skia/Avalonia.Skia/FormattedTextImpl.cs
+++ b/src/Skia/Avalonia.Skia/FormattedTextImpl.cs
@@ -615,6 +615,7 @@ private void SetForegroundBrush(IBrush brush, int startIndex, int length)
 
             if (brush != null)
             {
+                brush = brush.ToImmutable();
                 _foregroundBrushes.Insert(0, new KeyValuePair<FBrushRange, IBrush>(key, brush));
             }
         }
diff --git a/src/Skia/Avalonia.Skia/FramebufferRenderTarget.cs b/src/Skia/Avalonia.Skia/FramebufferRenderTarget.cs
index ae8e653e55e..1956f02d1bc 100644
--- a/src/Skia/Avalonia.Skia/FramebufferRenderTarget.cs
+++ b/src/Skia/Avalonia.Skia/FramebufferRenderTarget.cs
@@ -76,8 +76,7 @@ public IDrawingContextImpl CreateDrawingContext(IVisualBrushRenderer visualBrush
             canvas.RestoreToCount(0);
             canvas.Save();
             canvas.ResetMatrix();
-            var scale = Matrix.CreateScale(fb.Dpi.X / 96, fb.Dpi.Y / 96);
-            return new DrawingContextImpl(canvas, visualBrushRenderer, scale, canvas, surface, shim, fb);
+            return new DrawingContextImpl(canvas, fb.Dpi, visualBrushRenderer, canvas, surface, shim, fb);
         }
     }
 }
diff --git a/src/Skia/Avalonia.Skia/PlatformRenderInterface.cs b/src/Skia/Avalonia.Skia/PlatformRenderInterface.cs
index aea1dea5842..bd3769e4a56 100644
--- a/src/Skia/Avalonia.Skia/PlatformRenderInterface.cs
+++ b/src/Skia/Avalonia.Skia/PlatformRenderInterface.cs
@@ -77,7 +77,7 @@ public IRenderTargetBitmapImpl CreateRenderTargetBitmap(
             if (height < 1)
                 throw new ArgumentException("Height can't be less than 1", nameof(height));
 
-            return new BitmapImpl(width, height);
+            return new BitmapImpl(width, height, new Vector(dpiX, dpiY));
         }
 
         public virtual IRenderTarget CreateRenderTarget(IEnumerable<object> surfaces)
@@ -90,7 +90,7 @@ public virtual IRenderTarget CreateRenderTarget(IEnumerable<object> surfaces)
 
         public IWritableBitmapImpl CreateWritableBitmap(int width, int height, PixelFormat? format = null)
         {
-            return new BitmapImpl(width, height, format);
+            return new BitmapImpl(width, height, new Vector(96, 96), format);
         }
     }
 }
diff --git a/src/Skia/Avalonia.Skia/SkiaSharpExtensions.cs b/src/Skia/Avalonia.Skia/SkiaSharpExtensions.cs
index 8591f9218a6..158291de8e3 100644
--- a/src/Skia/Avalonia.Skia/SkiaSharpExtensions.cs
+++ b/src/Skia/Avalonia.Skia/SkiaSharpExtensions.cs
@@ -90,6 +90,17 @@ public static SKTextAlign ToSKTextAlign(this TextAlignment a)
             }
         }
 
+        public static TextAlignment ToAvalonia(this SKTextAlign a)
+        {
+            switch (a)
+            {
+                default:
+                case SKTextAlign.Left: return TextAlignment.Left;
+                case SKTextAlign.Center: return TextAlignment.Center;
+                case SKTextAlign.Right: return TextAlignment.Right;
+            }
+        }
+
         public static SKPath Clone(this SKPath src)
         {
             return src != null ? new SKPath(src) : null;
diff --git a/src/Windows/Avalonia.Direct2D1/Direct2D1Platform.cs b/src/Windows/Avalonia.Direct2D1/Direct2D1Platform.cs
index 3176dee7a4e..fd8364c03bb 100644
--- a/src/Windows/Avalonia.Direct2D1/Direct2D1Platform.cs
+++ b/src/Windows/Avalonia.Direct2D1/Direct2D1Platform.cs
@@ -191,4 +191,4 @@ public IBitmapImpl LoadBitmap(PixelFormat format, IntPtr data, int width, int he
             return new WicBitmapImpl(s_imagingFactory, format, data, width, height, stride);
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Windows/Avalonia.Direct2D1/Media/RadialGradientBrushImpl.cs b/src/Windows/Avalonia.Direct2D1/Media/RadialGradientBrushImpl.cs
index 85417fe9180..45932a4760b 100644
--- a/src/Windows/Avalonia.Direct2D1/Media/RadialGradientBrushImpl.cs
+++ b/src/Windows/Avalonia.Direct2D1/Media/RadialGradientBrushImpl.cs
@@ -25,11 +25,11 @@ public RadialGradientBrushImpl(
             }).ToArray();
 
             var centerPoint = brush.Center.ToPixels(destinationSize);
-            var GradientOriginOffset = brush.GradientOrigin.ToPixels(destinationSize);
+            var gradientOrigin = brush.GradientOrigin.ToPixels(destinationSize) - centerPoint;
             
             // Note: Direct2D supports RadiusX and RadiusY but Cairo backend supports only Radius property
-            var radiusX = brush.Radius;
-            var radiusY = brush.Radius;
+            var radiusX = brush.Radius * destinationSize.Width;
+            var radiusY = brush.Radius * destinationSize.Height;
 
             using (var stops = new SharpDX.Direct2D1.GradientStopCollection(
                 target,
@@ -41,7 +41,7 @@ public RadialGradientBrushImpl(
                     new SharpDX.Direct2D1.RadialGradientBrushProperties
                     {
                         Center = centerPoint.ToSharpDX(),
-                        GradientOriginOffset = GradientOriginOffset.ToSharpDX(),
+                        GradientOriginOffset = gradientOrigin.ToSharpDX(),
                         RadiusX = (float)radiusX,
                         RadiusY = (float)radiusY
                     },
diff --git a/src/Windows/Avalonia.Win32.Interop/Wpf/WpfTopLevelImpl.cs b/src/Windows/Avalonia.Win32.Interop/Wpf/WpfTopLevelImpl.cs
index fbed2f621c5..0c46eceef6a 100644
--- a/src/Windows/Avalonia.Win32.Interop/Wpf/WpfTopLevelImpl.cs
+++ b/src/Windows/Avalonia.Win32.Interop/Wpf/WpfTopLevelImpl.cs
@@ -13,6 +13,7 @@
 using Avalonia.Input.Raw;
 using Avalonia.Layout;
 using Avalonia.Platform;
+using Avalonia.Rendering;
 using Key = Avalonia.Input.Key;
 using KeyEventArgs = System.Windows.Input.KeyEventArgs;
 using MouseButton = System.Windows.Input.MouseButton;
@@ -88,6 +89,11 @@ private void OnSourceChanged(object sender, SourceChangedEventArgs e)
             _ttl.ScalingChanged?.Invoke(_ttl.Scaling);
         }
 
+        public IRenderer CreateRenderer(IRenderRoot root)
+        {
+            return new ImmediateRenderer(root);
+        }
+
         public void Dispose()
         {
             _ttl.Closed?.Invoke();
diff --git a/src/Windows/Avalonia.Win32/FramebufferManager.cs b/src/Windows/Avalonia.Win32/FramebufferManager.cs
index f0a64309187..bdc6fb29fd1 100644
--- a/src/Windows/Avalonia.Win32/FramebufferManager.cs
+++ b/src/Windows/Avalonia.Win32/FramebufferManager.cs
@@ -25,7 +25,7 @@ public ILockedFramebuffer Lock()
             UnmanagedMethods.GetClientRect(_hwnd, out rc);
             var width = rc.right - rc.left;
             var height = rc.bottom - rc.top;
-            if (_fb == null || _fb.Width != width || _fb.Height != height)
+            if ((_fb == null || _fb.Width != width || _fb.Height != height) && width > 0 && height > 0)
             {
                 _fb?.Deallocate();
                 _fb = null;
diff --git a/src/Windows/Avalonia.Win32/Win32Platform.cs b/src/Windows/Avalonia.Win32/Win32Platform.cs
index e02c67c0e6a..584a5ba39e9 100644
--- a/src/Windows/Avalonia.Win32/Win32Platform.cs
+++ b/src/Windows/Avalonia.Win32/Win32Platform.cs
@@ -25,17 +25,21 @@ namespace Avalonia
 {
     public static class Win32ApplicationExtensions
     {
-        public static T UseWin32<T>(this T builder) where T : AppBuilderBase<T>, new()
+        public static T UseWin32<T>(
+            this T builder,
+            bool deferredRendering = true) 
+                where T : AppBuilderBase<T>, new()
         {
-            builder.UseWindowingSubsystem(Win32.Win32Platform.Initialize, "Win32");
-            return builder;
+            return builder.UseWindowingSubsystem(
+                () => Win32.Win32Platform.Initialize(deferredRendering),
+                "Win32");
         }
     }
 }
 
 namespace Avalonia.Win32
 {
-    partial class Win32Platform : IPlatformThreadingInterface, IPlatformSettings, IWindowingPlatform, IPlatformIconLoader, IRendererFactory
+    partial class Win32Platform : IPlatformThreadingInterface, IPlatformSettings, IWindowingPlatform, IPlatformIconLoader
     {
         private static readonly Win32Platform s_instance = new Win32Platform();
         private static uint _uiThread;
@@ -54,6 +58,8 @@ public Win32Platform()
             CreateMessageWindow();
         }
 
+        public static bool UseDeferredRendering { get; set; }
+
         public Size DoubleClickSize => new Size(
             UnmanagedMethods.GetSystemMetrics(UnmanagedMethods.SystemMetric.SM_CXDOUBLECLK),
             UnmanagedMethods.GetSystemMetrics(UnmanagedMethods.SystemMetric.SM_CYDOUBLECLK));
@@ -61,6 +67,11 @@ public Win32Platform()
         public TimeSpan DoubleClickTime => TimeSpan.FromMilliseconds(UnmanagedMethods.GetDoubleClickTime());
 
         public static void Initialize()
+        {
+            Initialize(true);
+        }
+
+        public static void Initialize(bool deferredRendering = true)
         {
             AvaloniaLocator.CurrentMutable
                 .Bind<IClipboard>().ToSingleton<ClipboardImpl>()
@@ -69,11 +80,11 @@ public static void Initialize()
                 .Bind<IPlatformSettings>().ToConstant(s_instance)
                 .Bind<IPlatformThreadingInterface>().ToConstant(s_instance)
                 .Bind<IRenderLoop>().ToConstant(new RenderLoop(60))
-                .Bind<IRendererFactory>().ToConstant(s_instance)
                 .Bind<ISystemDialogImpl>().ToSingleton<SystemDialogImpl>()
                 .Bind<IWindowingPlatform>().ToConstant(s_instance)
                 .Bind<IPlatformIconLoader>().ToConstant(s_instance);
-            
+
+            UseDeferredRendering = deferredRendering;
             _uiThread = UnmanagedMethods.GetCurrentThreadId();
         }
 
@@ -197,10 +208,5 @@ public IPopupImpl CreatePopup()
         {
             return new PopupImpl();
         }
-
-        public IRenderer CreateRenderer(IRenderRoot root, IRenderLoop renderLoop)
-        {
-            return new ImmediateRenderer(root);
-        }
     }
 }
diff --git a/src/Windows/Avalonia.Win32/WindowImpl.cs b/src/Windows/Avalonia.Win32/WindowImpl.cs
index f1537e53f5d..feb7bdc2ee2 100644
--- a/src/Windows/Avalonia.Win32/WindowImpl.cs
+++ b/src/Windows/Avalonia.Win32/WindowImpl.cs
@@ -15,6 +15,7 @@
 using Avalonia.Win32.Input;
 using Avalonia.Win32.Interop;
 using static Avalonia.Win32.Interop.UnmanagedMethods;
+using Avalonia.Rendering;
 #if NETSTANDARD
 using Win32Exception = Avalonia.Win32.NetStandard.AvaloniaWin32Exception;
 #endif
@@ -90,6 +91,15 @@ public Size ClientSize
             }
         }
 
+
+        public IRenderer CreateRenderer(IRenderRoot root)
+        {
+            var loop = AvaloniaLocator.Current.GetService<IRenderLoop>();
+            return Win32Platform.UseDeferredRendering ?
+                (IRenderer)new DeferredRenderer(root, loop) :
+                new ImmediateRenderer(root);
+        }
+
         public void Resize(Size value)
         {
             if (value != ClientSize)
diff --git a/src/iOS/Avalonia.iOS/TopLevelImpl.cs b/src/iOS/Avalonia.iOS/TopLevelImpl.cs
index cf4801dbb75..dde78746544 100644
--- a/src/iOS/Avalonia.iOS/TopLevelImpl.cs
+++ b/src/iOS/Avalonia.iOS/TopLevelImpl.cs
@@ -18,6 +18,7 @@
 using ObjCRuntime;
 using Avalonia.Controls;
 using Avalonia.Controls.Platform.Surfaces;
+using Avalonia.Rendering;
 
 namespace Avalonia.iOS
 {
@@ -62,7 +63,12 @@ public TopLevelImpl()
         public Size ClientSize => Bounds.Size.ToAvalonia();
 
         public IMouseDevice MouseDevice => iOSPlatform.MouseDevice;
-        
+
+        public IRenderer CreateRenderer(IRenderRoot root)
+        {
+            return new ImmediateRenderer(root);
+        }
+
         public override void Draw(CGRect rect)
         {
             Paint?.Invoke(new Rect(rect.X, rect.Y, rect.Width, rect.Height));
diff --git a/src/iOS/Avalonia.iOS/iOSPlatform.cs b/src/iOS/Avalonia.iOS/iOSPlatform.cs
index 4c4e497cd71..7958b2e1357 100644
--- a/src/iOS/Avalonia.iOS/iOSPlatform.cs
+++ b/src/iOS/Avalonia.iOS/iOSPlatform.cs
@@ -57,7 +57,6 @@ public static void Initialize()
                 //.Bind<ISystemDialogImpl>().ToTransient<SystemDialogImpl>()
                 .Bind<IStandardCursorFactory>().ToTransient<CursorFactory>()
                 .Bind<IKeyboardDevice>().ToConstant(KeyboardDevice)
-                .Bind<IRendererFactory>().ToConstant(ImmediateRenderer.Factory)
                 .Bind<IPlatformSettings>().ToSingleton<PlatformSettings>()
                 .Bind<IPlatformThreadingInterface>().ToConstant(PlatformThreadingInterface.Instance)
                 .Bind<IPlatformIconLoader>().ToSingleton<PlatformIconLoader>()
diff --git a/tests/Avalonia.Controls.UnitTests/Presenters/ItemsPresenterTests_Virtualization.cs b/tests/Avalonia.Controls.UnitTests/Presenters/ItemsPresenterTests_Virtualization.cs
index 1ea64b915c0..58f4127cdcb 100644
--- a/tests/Avalonia.Controls.UnitTests/Presenters/ItemsPresenterTests_Virtualization.cs
+++ b/tests/Avalonia.Controls.UnitTests/Presenters/ItemsPresenterTests_Virtualization.cs
@@ -317,6 +317,7 @@ private class TestScroller : ScrollContentPresenter, IRenderRoot
         {
             public IRenderer Renderer { get; }
             public Size ClientSize { get; }
+            public double RenderScaling => 1;
 
             public IRenderTarget CreateRenderTarget()
             {
diff --git a/tests/Avalonia.Controls.UnitTests/Presenters/ItemsPresenterTests_Virtualization_Simple.cs b/tests/Avalonia.Controls.UnitTests/Presenters/ItemsPresenterTests_Virtualization_Simple.cs
index 1da9cfce76c..51433cc08ee 100644
--- a/tests/Avalonia.Controls.UnitTests/Presenters/ItemsPresenterTests_Virtualization_Simple.cs
+++ b/tests/Avalonia.Controls.UnitTests/Presenters/ItemsPresenterTests_Virtualization_Simple.cs
@@ -1034,6 +1034,7 @@ private class TestScroller : ScrollContentPresenter, IRenderRoot
         {
             public IRenderer Renderer { get; }
             public Size ClientSize { get; }
+            public double RenderScaling => 1;
 
             public IRenderTarget CreateRenderTarget()
             {
diff --git a/tests/Avalonia.Controls.UnitTests/WindowBaseTests.cs b/tests/Avalonia.Controls.UnitTests/WindowBaseTests.cs
index d6ffb32d1c4..019f78a2b0a 100644
--- a/tests/Avalonia.Controls.UnitTests/WindowBaseTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/WindowBaseTests.cs
@@ -27,6 +27,8 @@ public void Impl_ClientSize_Should_Be_Set_After_Layout_Pass()
             {
                 var impl = Mock.Of<IWindowBaseImpl>(x => x.Scaling == 1);
 
+                Mock.Get(impl).Setup(x => x.Resize(It.IsAny<Size>())).Callback(() => { });
+
                 var target = new TestWindowBase(impl)
                 {
                     Template = CreateTemplate(),
@@ -183,6 +185,56 @@ public void Setting_IsVisible_False_Hides_Window()
             }
         }
 
+        [Fact]
+        public void Showing_Should_Start_Renderer()
+        {
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var renderer = new Mock<IRenderer>();
+                var target = new TestWindowBase(renderer.Object);
+
+                target.Show();
+
+                renderer.Verify(x => x.Start(), Times.Once);
+            }
+        }
+
+        [Fact]
+        public void Hiding_Should_Stop_Renderer()
+        {
+
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var renderer = new Mock<IRenderer>();
+                var target = new TestWindowBase(renderer.Object);
+
+                target.Show();
+                target.Hide();
+
+                renderer.Verify(x => x.Stop(), Times.Once);
+            }
+        }
+
+        [Fact]
+        public void Renderer_Should_Be_Disposed_When_Impl_Signals_Close()
+        {
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var renderer = new Mock<IRenderer>();
+                var windowImpl = new Mock<IPopupImpl>();
+                windowImpl.Setup(x => x.Scaling).Returns(1);
+                windowImpl.SetupProperty(x => x.Closed);
+                windowImpl.Setup(x => x.CreateRenderer(It.IsAny<IRenderRoot>())).Returns(renderer.Object);
+
+                var target = new TestWindowBase(windowImpl.Object);
+
+                target.Show();
+                windowImpl.Object.Closed();
+
+                renderer.Verify(x => x.Dispose(), Times.Once);
+            }
+        }
+
         private FuncControlTemplate<TestWindowBase> CreateTemplate()
         {
             return new FuncControlTemplate<TestWindowBase>(x =>
@@ -197,8 +249,10 @@ private class TestWindowBase : WindowBase
         {
             public bool IsClosed { get; private set; }
 
-            public TestWindowBase()
-                : base(Mock.Of<IWindowBaseImpl>(x => x.Scaling == 1))
+            public TestWindowBase(IRenderer renderer = null)
+                : base(Mock.Of<IWindowBaseImpl>(x => 
+                    x.Scaling == 1 &&
+                    x.CreateRenderer(It.IsAny<IRenderRoot>()) == renderer))
             {
             }
 
diff --git a/tests/Avalonia.Controls.UnitTests/WindowTests.cs b/tests/Avalonia.Controls.UnitTests/WindowTests.cs
index e0dd908bbbd..df9ca6b1b17 100644
--- a/tests/Avalonia.Controls.UnitTests/WindowTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/WindowTests.cs
@@ -4,8 +4,10 @@
 // </copyright>
 // -----------------------------------------------------------------------
 
+using System;
 using System.Collections.Generic;
 using Avalonia.Platform;
+using Avalonia.Rendering;
 using Avalonia.UnitTests;
 using Moq;
 using Xunit;
@@ -185,11 +187,62 @@ public void Impl_Closing_Should_Remove_Window_From_OpenWindows()
             }
         }
 
+        [Fact]
+        public void Showing_Should_Start_Renderer()
+        {
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var renderer = new Mock<IRenderer>();
+                var target = new Window(CreateImpl(renderer));
+
+                target.Show();
+
+                renderer.Verify(x => x.Start(), Times.Once);
+            }
+        }
+
+        [Fact]
+        public void ShowDialog_Should_Start_Renderer()
+        {
+
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var renderer = new Mock<IRenderer>();
+                var target = new Window(CreateImpl(renderer));
+
+                target.Show();
+
+                renderer.Verify(x => x.Start(), Times.Once);
+            }
+        }
+
+        [Fact]
+        public void Hiding_Should_Stop_Renderer()
+        {
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var renderer = new Mock<IRenderer>();
+                var target = new Window(CreateImpl(renderer));
+
+                target.Show();
+                target.Hide();
+
+                renderer.Verify(x => x.Stop(), Times.Once);
+            }
+        }
+
         private void ClearOpenWindows()
         {
             // HACK: We really need a decent way to have "statics" that can be scoped to
             // AvaloniaLocator scopes.
             ((IList<Window>)Window.OpenWindows).Clear();
         }
+
+        private IWindowImpl CreateImpl(Mock<IRenderer> renderer)
+        {
+            return Mock.Of<IWindowImpl>(x =>
+                x.Scaling == 1 &&
+                x.CreateRenderer(It.IsAny<IRenderRoot>()) == renderer.Object);
+        }
     }
 }
diff --git a/tests/Avalonia.Input.UnitTests/Avalonia.Input.UnitTests.csproj b/tests/Avalonia.Input.UnitTests/Avalonia.Input.UnitTests.csproj
index 8dd8faf9db7..186d293b96c 100644
--- a/tests/Avalonia.Input.UnitTests/Avalonia.Input.UnitTests.csproj
+++ b/tests/Avalonia.Input.UnitTests/Avalonia.Input.UnitTests.csproj
@@ -3,6 +3,35 @@
     <TargetFrameworks>net461;netcoreapp1.1</TargetFrameworks>
     <OutputType>Library</OutputType>
   </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <DocumentationFile>bin\Debug\Avalonia.Input.UnitTests.XML</DocumentationFile>
+    <NoWarn>CS1591</NoWarn>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+    <Reference Include="WindowsBase" />
+  </ItemGroup>
   <Import Project="..\..\build\UnitTests.NetCore.targets" />
   <Import Project="..\..\build\Moq.props" />
   <Import Project="..\..\build\XUnit.props" />
diff --git a/tests/Avalonia.Input.UnitTests/MouseDeviceTests.cs b/tests/Avalonia.Input.UnitTests/MouseDeviceTests.cs
new file mode 100644
index 00000000000..4a834fd55da
--- /dev/null
+++ b/tests/Avalonia.Input.UnitTests/MouseDeviceTests.cs
@@ -0,0 +1,85 @@
+using Avalonia.Controls;
+using Avalonia.Input.Raw;
+using Avalonia.Layout;
+using Avalonia.Rendering;
+using Avalonia.UnitTests;
+using Avalonia.VisualTree;
+using Moq;
+using System;
+using Xunit;
+
+namespace Avalonia.Input.UnitTests
+{
+    public class MouseDeviceTests
+    {
+        [Fact]
+        public void MouseMove_Should_Update_PointerOver()
+        {
+            var renderer = new Mock<IRenderer>();
+
+            using (TestApplication(renderer.Object))
+            {
+                var inputManager = InputManager.Instance;
+
+                Canvas canvas;
+                Border border;
+                Decorator decorator;
+
+                var root = new TestRoot
+                {
+                    MouseDevice = new MouseDevice(),
+                    Renderer = renderer.Object,
+                    Child = new Panel
+                    {
+                        Children =
+                        {
+                            (canvas = new Canvas()),
+                            (border = new Border
+                            {
+                                Child = decorator = new Decorator(),
+                            })
+                        }
+                    }
+                };
+
+                renderer.Setup(x => x.HitTest(It.IsAny<Point>(), It.IsAny<Func<IVisual, bool>>()))
+                    .Returns(new[] { decorator });
+
+                inputManager.ProcessInput(new RawMouseEventArgs(
+                    root.MouseDevice,
+                    0,
+                    root,
+                    RawMouseEventType.Move,
+                    new Point(),
+                    InputModifiers.None));
+
+                Assert.True(decorator.IsPointerOver);
+                Assert.True(border.IsPointerOver);
+                Assert.False(canvas.IsPointerOver);
+                Assert.True(root.IsPointerOver);
+
+                renderer.Setup(x => x.HitTest(It.IsAny<Point>(), It.IsAny<Func<IVisual, bool>>()))
+                    .Returns(new[] { canvas });
+
+                inputManager.ProcessInput(new RawMouseEventArgs(
+                    root.MouseDevice,
+                    0,
+                    root,
+                    RawMouseEventType.Move,
+                    new Point(),
+                    InputModifiers.None));
+
+                Assert.False(decorator.IsPointerOver);
+                Assert.False(border.IsPointerOver);
+                Assert.True(canvas.IsPointerOver);
+                Assert.True(root.IsPointerOver);
+            }
+        }
+
+        private IDisposable TestApplication(IRenderer renderer)
+        {
+            return UnitTestApplication.Start(
+                new TestServices(inputManager: new InputManager()));
+        }
+    }
+}
diff --git a/tests/Avalonia.LeakTests/ControlTests.cs b/tests/Avalonia.LeakTests/ControlTests.cs
index b9bdee09e6d..e0b0d4a4c0e 100644
--- a/tests/Avalonia.LeakTests/ControlTests.cs
+++ b/tests/Avalonia.LeakTests/ControlTests.cs
@@ -318,12 +318,11 @@ public void RendererIsDisposed()
                 var impl = new Mock<IWindowImpl>();
                 impl.SetupGet(x => x.Scaling).Returns(1);
                 impl.SetupProperty(x => x.Closed);
+                impl.Setup(x => x.CreateRenderer(It.IsAny<IRenderRoot>())).Returns(renderer.Object);
                 impl.Setup(x => x.Dispose()).Callback(() => impl.Object.Closed());
 
                 AvaloniaLocator.CurrentMutable.Bind<IWindowingPlatform>()
                     .ToConstant(new MockWindowingPlatform(() => impl.Object));
-                AvaloniaLocator.CurrentMutable.Bind<IRendererFactory>()
-                    .ToConstant(new MockRendererFactory(renderer.Object));
                 var window = new Window()
                 {
                     Content = new Button()
@@ -336,8 +335,7 @@ public void RendererIsDisposed()
 
         private IDisposable Start()
         {
-            var services = TestServices.StyledWindow.With(renderer: (root, loop) => new NullRenderer());
-            return UnitTestApplication.Start(services);
+            return UnitTestApplication.Start(TestServices.StyledWindow);
         }
 
         private class Node
@@ -368,6 +366,14 @@ public void Paint(Rect rect)
             public void Resized(Size size)
             {
             }
+
+            public void Start()
+            {
+            }
+
+            public void Stop()
+            {
+            }
         }
     }
 }
diff --git a/tests/Avalonia.RenderTests/Avalonia.Cairo.RenderTests.v2.ncrunchproject b/tests/Avalonia.RenderTests/Avalonia.Cairo.RenderTests.v2.ncrunchproject
deleted file mode 100644
index ed3fd080b1a..00000000000
--- a/tests/Avalonia.RenderTests/Avalonia.Cairo.RenderTests.v2.ncrunchproject
+++ /dev/null
@@ -1,27 +0,0 @@
-<ProjectConfiguration>
-  <AutoDetectNugetBuildDependencies>true</AutoDetectNugetBuildDependencies>
-  <BuildPriority>1000</BuildPriority>
-  <CopyReferencedAssembliesToWorkspace>false</CopyReferencedAssembliesToWorkspace>
-  <ConsiderInconclusiveTestsAsPassing>false</ConsiderInconclusiveTestsAsPassing>
-  <PreloadReferencedAssemblies>false</PreloadReferencedAssemblies>
-  <AllowDynamicCodeContractChecking>true</AllowDynamicCodeContractChecking>
-  <AllowStaticCodeContractChecking>false</AllowStaticCodeContractChecking>
-  <AllowCodeAnalysis>false</AllowCodeAnalysis>
-  <IgnoreThisComponentCompletely>false</IgnoreThisComponentCompletely>
-  <RunPreBuildEvents>false</RunPreBuildEvents>
-  <RunPostBuildEvents>false</RunPostBuildEvents>
-  <PreviouslyBuiltSuccessfully>true</PreviouslyBuiltSuccessfully>
-  <InstrumentAssembly>true</InstrumentAssembly>
-  <PreventSigningOfAssembly>false</PreventSigningOfAssembly>
-  <AnalyseExecutionTimes>true</AnalyseExecutionTimes>
-  <DetectStackOverflow>true</DetectStackOverflow>
-  <IncludeStaticReferencesInWorkspace>true</IncludeStaticReferencesInWorkspace>
-  <DefaultTestTimeout>60000</DefaultTestTimeout>
-  <UseBuildConfiguration />
-  <UseBuildPlatform />
-  <ProxyProcessPath />
-  <UseCPUArchitecture>AutoDetect</UseCPUArchitecture>
-  <MSTestThreadApartmentState>STA</MSTestThreadApartmentState>
-  <BuildProcessArchitecture>x86</BuildProcessArchitecture>
-  <HiddenWarnings>AbnormalReferenceResolution</HiddenWarnings>
-</ProjectConfiguration>
\ No newline at end of file
diff --git a/tests/Avalonia.RenderTests/Avalonia.Direct2D1.RenderTests.v2.ncrunchproject b/tests/Avalonia.RenderTests/Avalonia.Direct2D1.RenderTests.v2.ncrunchproject
deleted file mode 100644
index 30815b1937d..00000000000
--- a/tests/Avalonia.RenderTests/Avalonia.Direct2D1.RenderTests.v2.ncrunchproject
+++ /dev/null
@@ -1,26 +0,0 @@
-<ProjectConfiguration>
-  <AutoDetectNugetBuildDependencies>true</AutoDetectNugetBuildDependencies>
-  <BuildPriority>1000</BuildPriority>
-  <CopyReferencedAssembliesToWorkspace>false</CopyReferencedAssembliesToWorkspace>
-  <ConsiderInconclusiveTestsAsPassing>false</ConsiderInconclusiveTestsAsPassing>
-  <PreloadReferencedAssemblies>false</PreloadReferencedAssemblies>
-  <AllowDynamicCodeContractChecking>true</AllowDynamicCodeContractChecking>
-  <AllowStaticCodeContractChecking>false</AllowStaticCodeContractChecking>
-  <AllowCodeAnalysis>false</AllowCodeAnalysis>
-  <IgnoreThisComponentCompletely>false</IgnoreThisComponentCompletely>
-  <RunPreBuildEvents>false</RunPreBuildEvents>
-  <RunPostBuildEvents>false</RunPostBuildEvents>
-  <PreviouslyBuiltSuccessfully>true</PreviouslyBuiltSuccessfully>
-  <InstrumentAssembly>true</InstrumentAssembly>
-  <PreventSigningOfAssembly>false</PreventSigningOfAssembly>
-  <AnalyseExecutionTimes>true</AnalyseExecutionTimes>
-  <DetectStackOverflow>true</DetectStackOverflow>
-  <IncludeStaticReferencesInWorkspace>true</IncludeStaticReferencesInWorkspace>
-  <DefaultTestTimeout>60000</DefaultTestTimeout>
-  <UseBuildConfiguration />
-  <UseBuildPlatform />
-  <ProxyProcessPath />
-  <UseCPUArchitecture>AutoDetect</UseCPUArchitecture>
-  <MSTestThreadApartmentState>STA</MSTestThreadApartmentState>
-  <BuildProcessArchitecture>x86</BuildProcessArchitecture>
-</ProjectConfiguration>
\ No newline at end of file
diff --git a/tests/Avalonia.RenderTests/Avalonia.RenderTests.projitems b/tests/Avalonia.RenderTests/Avalonia.RenderTests.projitems
index e26ac81dda8..a3ca0c74936 100644
--- a/tests/Avalonia.RenderTests/Avalonia.RenderTests.projitems
+++ b/tests/Avalonia.RenderTests/Avalonia.RenderTests.projitems
@@ -9,7 +9,9 @@
     <Import_RootNamespace>Avalonia.RenderTests</Import_RootNamespace>
   </PropertyGroup>
   <ItemGroup>
+    <Compile Include="$(MSBuildThisFileDirectory)Controls\CustomRenderTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)GeometryClippingTests.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Media\RadialGradientBrushTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Media\BitmapTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)OpacityMaskTests.cs" />
     <Compile Include="Media\FormattedTextImplTests.cs" />
diff --git a/tests/Avalonia.RenderTests/Avalonia.Skia.RenderTests.v2.ncrunchproject b/tests/Avalonia.RenderTests/Avalonia.Skia.RenderTests.v2.ncrunchproject
deleted file mode 100644
index e1b4d7cf284..00000000000
--- a/tests/Avalonia.RenderTests/Avalonia.Skia.RenderTests.v2.ncrunchproject
+++ /dev/null
@@ -1,26 +0,0 @@
-<ProjectConfiguration>
-  <AutoDetectNugetBuildDependencies>true</AutoDetectNugetBuildDependencies>
-  <BuildPriority>1000</BuildPriority>
-  <CopyReferencedAssembliesToWorkspace>false</CopyReferencedAssembliesToWorkspace>
-  <ConsiderInconclusiveTestsAsPassing>false</ConsiderInconclusiveTestsAsPassing>
-  <PreloadReferencedAssemblies>false</PreloadReferencedAssemblies>
-  <AllowDynamicCodeContractChecking>true</AllowDynamicCodeContractChecking>
-  <AllowStaticCodeContractChecking>false</AllowStaticCodeContractChecking>
-  <AllowCodeAnalysis>false</AllowCodeAnalysis>
-  <IgnoreThisComponentCompletely>true</IgnoreThisComponentCompletely>
-  <RunPreBuildEvents>false</RunPreBuildEvents>
-  <RunPostBuildEvents>false</RunPostBuildEvents>
-  <PreviouslyBuiltSuccessfully>false</PreviouslyBuiltSuccessfully>
-  <InstrumentAssembly>true</InstrumentAssembly>
-  <PreventSigningOfAssembly>false</PreventSigningOfAssembly>
-  <AnalyseExecutionTimes>true</AnalyseExecutionTimes>
-  <DetectStackOverflow>true</DetectStackOverflow>
-  <IncludeStaticReferencesInWorkspace>true</IncludeStaticReferencesInWorkspace>
-  <DefaultTestTimeout>60000</DefaultTestTimeout>
-  <UseBuildConfiguration />
-  <UseBuildPlatform />
-  <ProxyProcessPath />
-  <UseCPUArchitecture>AutoDetect</UseCPUArchitecture>
-  <MSTestThreadApartmentState>STA</MSTestThreadApartmentState>
-  <BuildProcessArchitecture>x86</BuildProcessArchitecture>
-</ProjectConfiguration>
\ No newline at end of file
diff --git a/tests/Avalonia.RenderTests/Controls/BorderTests.cs b/tests/Avalonia.RenderTests/Controls/BorderTests.cs
index 369f4b3031e..ef33ecad8e3 100644
--- a/tests/Avalonia.RenderTests/Controls/BorderTests.cs
+++ b/tests/Avalonia.RenderTests/Controls/BorderTests.cs
@@ -1,6 +1,7 @@
 // Copyright (c) The Avalonia Project. All rights reserved.
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
+using System.Threading.Tasks;
 using Avalonia.Controls;
 using Avalonia.Layout;
 using Avalonia.Media;
@@ -22,7 +23,7 @@ public BorderTests()
         }
 
         [Fact]
-        public void Border_1px_Border()
+        public async Task Border_1px_Border()
         {
             Decorator target = new Decorator
             {
@@ -36,12 +37,12 @@ public void Border_1px_Border()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void Border_2px_Border()
+        public async Task Border_2px_Border()
         {
             Decorator target = new Decorator
             {
@@ -55,12 +56,12 @@ public void Border_2px_Border()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void Border_Fill()
+        public async Task Border_Fill()
         {
             Decorator target = new Decorator
             {
@@ -73,12 +74,12 @@ public void Border_Fill()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void Border_Brush_Offsets_Content()
+        public async Task Border_Brush_Offsets_Content()
         {
             Decorator target = new Decorator
             {
@@ -96,12 +97,12 @@ public void Border_Brush_Offsets_Content()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void Border_Padding_Offsets_Content()
+        public async Task Border_Padding_Offsets_Content()
         {
             Decorator target = new Decorator
             {
@@ -120,12 +121,12 @@ public void Border_Padding_Offsets_Content()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void Border_Margin_Offsets_Content()
+        public async Task Border_Margin_Offsets_Content()
         {
             Decorator target = new Decorator
             {
@@ -144,7 +145,7 @@ public void Border_Margin_Offsets_Content()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -153,7 +154,7 @@ public void Border_Margin_Offsets_Content()
 #else
         [Fact]
 #endif
-        public void Border_Centers_Content_Horizontally()
+        public async Task Border_Centers_Content_Horizontally()
         {
             Decorator target = new Decorator
             {
@@ -175,7 +176,7 @@ public void Border_Centers_Content_Horizontally()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -184,7 +185,7 @@ public void Border_Centers_Content_Horizontally()
 #else
         [Fact]
 #endif
-        public void Border_Centers_Content_Vertically()
+        public async Task Border_Centers_Content_Vertically()
         {
             Decorator target = new Decorator
             {
@@ -206,7 +207,7 @@ public void Border_Centers_Content_Vertically()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -215,7 +216,7 @@ public void Border_Centers_Content_Vertically()
 #else
         [Fact]
 #endif
-        public void Border_Stretches_Content_Horizontally()
+        public async Task Border_Stretches_Content_Horizontally()
         {
             Decorator target = new Decorator
             {
@@ -237,7 +238,7 @@ public void Border_Stretches_Content_Horizontally()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -246,7 +247,7 @@ public void Border_Stretches_Content_Horizontally()
 #else
         [Fact]
 #endif
-        public void Border_Stretches_Content_Vertically()
+        public async Task Border_Stretches_Content_Vertically()
         {
             Decorator target = new Decorator
             {
@@ -268,7 +269,7 @@ public void Border_Stretches_Content_Vertically()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -277,7 +278,7 @@ public void Border_Stretches_Content_Vertically()
 #else
         [Fact]
 #endif
-        public void Border_Left_Aligns_Content()
+        public async Task Border_Left_Aligns_Content()
         {
             Decorator target = new Decorator
             {
@@ -299,7 +300,7 @@ public void Border_Left_Aligns_Content()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -308,7 +309,7 @@ public void Border_Left_Aligns_Content()
 #else
         [Fact]
 #endif
-        public void Border_Right_Aligns_Content()
+        public async Task Border_Right_Aligns_Content()
         {
             Decorator target = new Decorator
             {
@@ -330,7 +331,7 @@ public void Border_Right_Aligns_Content()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -339,7 +340,7 @@ public void Border_Right_Aligns_Content()
 #else
         [Fact]
 #endif
-        public void Border_Top_Aligns_Content()
+        public async Task Border_Top_Aligns_Content()
         {
             Decorator target = new Decorator
             {
@@ -361,7 +362,7 @@ public void Border_Top_Aligns_Content()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -370,7 +371,7 @@ public void Border_Top_Aligns_Content()
 #else
         [Fact]
 #endif
-        public void Border_Bottom_Aligns_Content()
+        public async Task Border_Bottom_Aligns_Content()
         {
             Decorator target = new Decorator
             {
@@ -392,12 +393,12 @@ public void Border_Bottom_Aligns_Content()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void Border_Nested_Rotate()
+        public async Task Border_Nested_Rotate()
         {
             Decorator target = new Decorator
             {
@@ -420,7 +421,7 @@ public void Border_Nested_Rotate()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
     }
diff --git a/tests/Avalonia.RenderTests/Controls/CustomRenderTests.cs b/tests/Avalonia.RenderTests/Controls/CustomRenderTests.cs
new file mode 100644
index 00000000000..e4630d82653
--- /dev/null
+++ b/tests/Avalonia.RenderTests/Controls/CustomRenderTests.cs
@@ -0,0 +1,162 @@
+// Copyright (c) The Avalonia Project. All rights reserved.
+// Licensed under the MIT license. See licence.md file in the project root for full license information.
+
+using System;
+using System.Threading.Tasks;
+using Avalonia.Controls;
+using Avalonia.Layout;
+using Avalonia.Media;
+using Xunit;
+
+#if AVALONIA_CAIRO
+namespace Avalonia.Cairo.RenderTests.Controls
+#elif AVALONIA_SKIA
+namespace Avalonia.Skia.RenderTests
+#else
+namespace Avalonia.Direct2D1.RenderTests.Controls
+#endif
+{
+    public class CustomRenderTests : TestBase
+    {
+        public CustomRenderTests()
+            : base(@"Controls\CustomRender")
+        {
+        }
+
+        [Fact]
+        public async Task Clip()
+        {
+            Decorator target = new Decorator
+            {
+                Padding = new Thickness(8),
+                Width = 200,
+                Height = 200,
+                Child = new CustomRenderer((control, context) =>
+                {
+                    context.FillRectangle(
+                        Brushes.Red,
+                        new Rect(control.Bounds.Size),
+                        4);
+
+                    using (context.PushClip(new Rect(control.Bounds.Size).Deflate(20)))
+                    {
+                        context.FillRectangle(
+                            Brushes.Blue,
+                            new Rect(control.Bounds.Size),
+                            4);
+                    }
+                }),
+            };
+
+            await RenderToFile(target);
+            CompareImages();
+        }
+
+        [Fact]
+        public async Task GeometryClip()
+        {
+            Decorator target = new Decorator
+            {
+                Padding = new Thickness(8),
+                Width = 200,
+                Height = 200,
+                Child = new CustomRenderer((control, context) =>
+                {
+                    var clip = new EllipseGeometry(new Rect(control.Bounds.Size));
+
+                    context.FillRectangle(
+                        Brushes.Red,
+                        new Rect(control.Bounds.Size),
+                        4);
+
+                    using (context.PushGeometryClip(clip))
+                    {
+                        context.FillRectangle(
+                            Brushes.Blue,
+                            new Rect(control.Bounds.Size),
+                            4);
+                    }
+                }),
+            };
+
+            await RenderToFile(target);
+            CompareImages();
+        }
+
+        [Fact]
+        public async Task Opacity()
+        {
+            Decorator target = new Decorator
+            {
+                Padding = new Thickness(8),
+                Width = 200,
+                Height = 200,
+                Child = new CustomRenderer((control, context) =>
+                {
+                    context.FillRectangle(
+                        Brushes.Red,
+                        new Rect(control.Bounds.Size),
+                        4);
+
+                    using (context.PushOpacity(0.5))
+                    {
+                        context.FillRectangle(
+                            Brushes.Blue,
+                            new Rect(control.Bounds.Size).Deflate(20),
+                            4);
+                    }
+                }),
+            };
+
+            await RenderToFile(target);
+            CompareImages();
+        }
+
+        [Fact]
+        public async Task OpacityMask()
+        {
+            Decorator target = new Decorator
+            {
+                Padding = new Thickness(8),
+                Width = 200,
+                Height = 200,
+                Child = new CustomRenderer((control, context) =>
+                {
+                    var mask = new LinearGradientBrush
+                    {
+                        StartPoint = new RelativePoint(0, 0, RelativeUnit.Relative),
+                        EndPoint = new RelativePoint(1, 1, RelativeUnit.Relative),
+                        GradientStops = new[]
+                        {
+                            new GradientStop(Color.FromUInt32(0xffffffff), 0),
+                            new GradientStop(Color.FromUInt32(0x00ffffff), 1)
+                        },
+                    };
+
+                    context.FillRectangle(
+                        Brushes.Red,
+                        new Rect(control.Bounds.Size),
+                        4);
+
+                    using (context.PushOpacityMask(mask, new Rect(control.Bounds.Size)))
+                    {
+                        context.FillRectangle(
+                            Brushes.Blue,
+                            new Rect(control.Bounds.Size).Deflate(20),
+                            4);
+                    }
+                }),
+            };
+
+            await RenderToFile(target);
+            CompareImages();
+        }
+
+        class CustomRenderer : Control
+        {
+            private Action<CustomRenderer, DrawingContext> _render;
+            public CustomRenderer(Action<CustomRenderer, DrawingContext> render) => _render = render;
+            public override void Render(DrawingContext context) => _render(this, context);
+        }
+    }
+}
diff --git a/tests/Avalonia.RenderTests/Controls/ImageTests.cs b/tests/Avalonia.RenderTests/Controls/ImageTests.cs
index fcc99398f97..9c1d3624d15 100644
--- a/tests/Avalonia.RenderTests/Controls/ImageTests.cs
+++ b/tests/Avalonia.RenderTests/Controls/ImageTests.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
 using System.IO;
+using System.Threading.Tasks;
 using Avalonia.Controls;
 using Avalonia.Media;
 using Avalonia.Media.Imaging;
@@ -26,7 +27,7 @@ public ImageTests()
         }
 
         [Fact]
-        public void Image_Stretch_None()
+        public async Task Image_Stretch_None()
         {
             Decorator target = new Decorator
             {
@@ -44,12 +45,12 @@ public void Image_Stretch_None()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void Image_Stretch_Fill()
+        public async Task Image_Stretch_Fill()
         {
             Decorator target = new Decorator
             {
@@ -67,12 +68,12 @@ public void Image_Stretch_Fill()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void Image_Stretch_Uniform()
+        public async Task Image_Stretch_Uniform()
         {
             Decorator target = new Decorator
             {
@@ -90,12 +91,12 @@ public void Image_Stretch_Uniform()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void Image_Stretch_UniformToFill()
+        public async Task Image_Stretch_UniformToFill()
         {
             Decorator target = new Decorator
             {
@@ -113,7 +114,7 @@ public void Image_Stretch_UniformToFill()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
     }
diff --git a/tests/Avalonia.RenderTests/GeometryClippingTests.cs b/tests/Avalonia.RenderTests/GeometryClippingTests.cs
index 355606bb43a..a1ce8097bd0 100644
--- a/tests/Avalonia.RenderTests/GeometryClippingTests.cs
+++ b/tests/Avalonia.RenderTests/GeometryClippingTests.cs
@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Text;
 using Xunit;
+using System.Threading.Tasks;
 
 #if AVALONIA_CAIRO
 namespace Avalonia.Cairo.RenderTests
@@ -22,10 +23,11 @@ public GeometryClippingTests()
         }
 
         [Fact]
-        public void Geometry_Clip_Clips_Path()
+        public async Task Geometry_Clip_Clips_Path()
         {
             var target = new Canvas
             {
+                Background = Brushes.Yellow,
                 Clip = StreamGeometry.Parse("F1 M 0,0  H 76 V 76 Z"),
                 Width = 76,
                 Height = 76,
@@ -44,7 +46,7 @@ public void Geometry_Clip_Clips_Path()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
     }
diff --git a/tests/Avalonia.RenderTests/Media/BitmapTests.cs b/tests/Avalonia.RenderTests/Media/BitmapTests.cs
index 57f1e40d12a..33c14fb9754 100644
--- a/tests/Avalonia.RenderTests/Media/BitmapTests.cs
+++ b/tests/Avalonia.RenderTests/Media/BitmapTests.cs
@@ -102,7 +102,7 @@ public void FramebufferRenderResultsShouldBeUsableAsBitmap(PixelFormat fmt)
                 }
                 rtb.Save(System.IO.Path.Combine(OutputPath, testName + ".out.png"));
             }
-            CompareImages(testName);
+            CompareImagesNoRenderer(testName);
         }
 
 #if AVALONIA_CAIRO
@@ -133,7 +133,7 @@ public void WritableBitmapShouldBeUsable(PixelFormat fmt)
             var name = nameof(WritableBitmapShouldBeUsable) + "_" + fmt;
 
             writableBitmap.Save(System.IO.Path.Combine(OutputPath, name + ".out.png"));
-            CompareImages(name);
+            CompareImagesNoRenderer(name);
 
         }
     }
diff --git a/tests/Avalonia.RenderTests/Media/ImageBrushTests.cs b/tests/Avalonia.RenderTests/Media/ImageBrushTests.cs
index f4e44a81f08..b8f81696b1d 100644
--- a/tests/Avalonia.RenderTests/Media/ImageBrushTests.cs
+++ b/tests/Avalonia.RenderTests/Media/ImageBrushTests.cs
@@ -1,6 +1,7 @@
 // Copyright (c) The Avalonia Project. All rights reserved.
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
+using System.Threading.Tasks;
 using Avalonia.Controls;
 using Avalonia.Controls.Shapes;
 using Avalonia.Layout;
@@ -34,7 +35,7 @@ private string SmallBitmapPath
         }
 
         [Fact]
-        public void ImageBrush_Tile_Fill()
+        public async Task ImageBrush_Tile_Fill()
         {
             Decorator target = new Decorator
             {
@@ -53,12 +54,12 @@ public void ImageBrush_Tile_Fill()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void ImageBrush_Tile_UniformToFill()
+        public async Task ImageBrush_Tile_UniformToFill()
         {
             Decorator target = new Decorator
             {
@@ -77,12 +78,12 @@ public void ImageBrush_Tile_UniformToFill()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void ImageBrush_Tile_Small_Image()
+        public async Task ImageBrush_Tile_Small_Image()
         {
             Decorator target = new Decorator
             {
@@ -100,12 +101,12 @@ public void ImageBrush_Tile_Small_Image()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void ImageBrush_NoStretch_NoTile_Alignment_TopLeft()
+        public async Task ImageBrush_NoStretch_NoTile_Alignment_TopLeft()
         {
             Decorator target = new Decorator
             {
@@ -125,12 +126,12 @@ public void ImageBrush_NoStretch_NoTile_Alignment_TopLeft()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void ImageBrush_NoStretch_NoTile_Alignment_Center()
+        public async Task ImageBrush_NoStretch_NoTile_Alignment_Center()
         {
             Decorator target = new Decorator
             {
@@ -150,12 +151,12 @@ public void ImageBrush_NoStretch_NoTile_Alignment_Center()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void ImageBrush_NoStretch_NoTile_Alignment_BottomRight()
+        public async Task ImageBrush_NoStretch_NoTile_Alignment_BottomRight()
         {
             Decorator target = new Decorator
             {
@@ -175,7 +176,7 @@ public void ImageBrush_NoStretch_NoTile_Alignment_BottomRight()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 #if AVALONIA_SKIA_SKIP_FAIL
@@ -183,7 +184,7 @@ public void ImageBrush_NoStretch_NoTile_Alignment_BottomRight()
 #else
         [Fact]
 #endif
-        public void ImageBrush_Fill_NoTile()
+        public async Task ImageBrush_Fill_NoTile()
         {
             Decorator target = new Decorator
             {
@@ -201,7 +202,7 @@ public void ImageBrush_Fill_NoTile()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -210,7 +211,7 @@ public void ImageBrush_Fill_NoTile()
 #else
         [Fact]
 #endif
-        public void ImageBrush_Uniform_NoTile()
+        public async Task ImageBrush_Uniform_NoTile()
         {
             Decorator target = new Decorator
             {
@@ -228,7 +229,7 @@ public void ImageBrush_Uniform_NoTile()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -237,7 +238,7 @@ public void ImageBrush_Uniform_NoTile()
 #else
         [Fact]
 #endif
-        public void ImageBrush_UniformToFill_NoTile()
+        public async Task ImageBrush_UniformToFill_NoTile()
         {
             Decorator target = new Decorator
             {
@@ -255,12 +256,12 @@ public void ImageBrush_UniformToFill_NoTile()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void ImageBrush_NoStretch_NoTile_BottomRightQuarterSource()
+        public async Task ImageBrush_NoStretch_NoTile_BottomRightQuarterSource()
         {
             Decorator target = new Decorator
             {
@@ -279,7 +280,7 @@ public void ImageBrush_NoStretch_NoTile_BottomRightQuarterSource()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -288,7 +289,7 @@ public void ImageBrush_NoStretch_NoTile_BottomRightQuarterSource()
 #else
         [Fact]
 #endif
-        public void ImageBrush_NoStretch_NoTile_BottomRightQuarterDest()
+        public async Task ImageBrush_NoStretch_NoTile_BottomRightQuarterDest()
         {
             Decorator target = new Decorator
             {
@@ -307,7 +308,7 @@ public void ImageBrush_NoStretch_NoTile_BottomRightQuarterDest()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -316,7 +317,7 @@ public void ImageBrush_NoStretch_NoTile_BottomRightQuarterDest()
 #else
         [Fact]
 #endif
-        public void ImageBrush_NoStretch_NoTile_BottomRightQuarterSource_BottomRightQuarterDest()
+        public async Task ImageBrush_NoStretch_NoTile_BottomRightQuarterSource_BottomRightQuarterDest()
         {
             Decorator target = new Decorator
             {
@@ -336,12 +337,12 @@ public void ImageBrush_NoStretch_NoTile_BottomRightQuarterSource_BottomRightQuar
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void ImageBrush_NoStretch_Tile_BottomRightQuarterSource_CenterQuarterDest()
+        public async Task ImageBrush_NoStretch_Tile_BottomRightQuarterSource_CenterQuarterDest()
         {
             Decorator target = new Decorator
             {
@@ -361,7 +362,7 @@ public void ImageBrush_NoStretch_Tile_BottomRightQuarterSource_CenterQuarterDest
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -370,7 +371,7 @@ public void ImageBrush_NoStretch_Tile_BottomRightQuarterSource_CenterQuarterDest
 #else
         [Fact]
 #endif
-        public void ImageBrush_NoStretch_FlipX_TopLeftDest()
+        public async Task ImageBrush_NoStretch_FlipX_TopLeftDest()
         {
             Decorator target = new Decorator
             {
@@ -389,7 +390,7 @@ public void ImageBrush_NoStretch_FlipX_TopLeftDest()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -398,7 +399,7 @@ public void ImageBrush_NoStretch_FlipX_TopLeftDest()
 #else
         [Fact]
 #endif
-        public void ImageBrush_NoStretch_FlipY_TopLeftDest()
+        public async Task ImageBrush_NoStretch_FlipY_TopLeftDest()
         {
             Decorator target = new Decorator
             {
@@ -417,12 +418,12 @@ public void ImageBrush_NoStretch_FlipY_TopLeftDest()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void ImageBrush_NoStretch_FlipXY_TopLeftDest()
+        public async Task ImageBrush_NoStretch_FlipXY_TopLeftDest()
         {
             Decorator target = new Decorator
             {
@@ -441,7 +442,7 @@ public void ImageBrush_NoStretch_FlipXY_TopLeftDest()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
     }
diff --git a/tests/Avalonia.RenderTests/Media/LinearGradientBrushTests.cs b/tests/Avalonia.RenderTests/Media/LinearGradientBrushTests.cs
index 6c26d067a7f..e7889672b94 100644
--- a/tests/Avalonia.RenderTests/Media/LinearGradientBrushTests.cs
+++ b/tests/Avalonia.RenderTests/Media/LinearGradientBrushTests.cs
@@ -29,7 +29,7 @@ public LinearGradientBrushTests() : base(@"Media\LinearGradientBrush")
 #else
         [Fact]
 #endif
-        public void LinearGradientBrush_RedBlue_Horizontal_Fill()
+        public async Task LinearGradientBrush_RedBlue_Horizontal_Fill()
         {
             Decorator target = new Decorator
             {
@@ -51,7 +51,7 @@ public void LinearGradientBrush_RedBlue_Horizontal_Fill()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -60,7 +60,7 @@ public void LinearGradientBrush_RedBlue_Horizontal_Fill()
 #else
         [Fact]
 #endif
-        public void LinearGradientBrush_RedBlue_Vertical_Fill()
+        public async Task LinearGradientBrush_RedBlue_Vertical_Fill()
         {
             Decorator target = new Decorator
             {
@@ -82,7 +82,7 @@ public void LinearGradientBrush_RedBlue_Vertical_Fill()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
     }
diff --git a/tests/Avalonia.RenderTests/Media/RadialGradientBrushTests.cs b/tests/Avalonia.RenderTests/Media/RadialGradientBrushTests.cs
new file mode 100644
index 00000000000..383c8ee0f82
--- /dev/null
+++ b/tests/Avalonia.RenderTests/Media/RadialGradientBrushTests.cs
@@ -0,0 +1,56 @@
+// Copyright (c) The Avalonia Project. All rights reserved.
+// Licensed under the MIT license. See licence.md file in the project root for full license information.
+
+using Avalonia.Controls;
+using Avalonia.Media;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+#if AVALONIA_CAIRO
+namespace Avalonia.Cairo.RenderTests.Media
+#elif AVALONIA_SKIA
+namespace Avalonia.Skia.RenderTests
+#else
+namespace Avalonia.Direct2D1.RenderTests.Media
+#endif
+{
+    public class RadialGradientBrushTests : TestBase
+    {
+        public RadialGradientBrushTests() : base(@"Media\RadialGradientBrush")
+        {
+        }
+
+#if AVALONIA_SKIA_SKIP_FAIL
+        [Fact(Skip = "FIXME")]
+#else
+        [Fact]
+#endif
+        public async Task RadialGradientBrush_RedBlue()
+        {
+            Decorator target = new Decorator
+            {
+                Padding = new Thickness(8),
+                Width = 200,
+                Height = 200,
+                Child = new Border
+                {
+                    Background = new RadialGradientBrush
+                    {
+                        GradientStops = new[]
+                        {
+                            new GradientStop { Color = Colors.Red, Offset = 0 },
+                            new GradientStop { Color = Colors.Blue, Offset = 1 }
+                        }
+                    }
+                }
+            };
+
+            await RenderToFile(target);
+            CompareImages();
+        }
+    }
+}
diff --git a/tests/Avalonia.RenderTests/Media/VisualBrushTests.cs b/tests/Avalonia.RenderTests/Media/VisualBrushTests.cs
index a50bd1a2c9f..9ec901535ab 100644
--- a/tests/Avalonia.RenderTests/Media/VisualBrushTests.cs
+++ b/tests/Avalonia.RenderTests/Media/VisualBrushTests.cs
@@ -1,6 +1,7 @@
 // Copyright (c) The Avalonia Project. All rights reserved.
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
+using System.Threading.Tasks;
 using Avalonia.Controls;
 using Avalonia.Controls.Shapes;
 using Avalonia.Layout;
@@ -61,7 +62,7 @@ private Control Visual
         }
 
         [Fact]
-        public void VisualBrush_NoStretch_NoTile_Alignment_TopLeft()
+        public async Task VisualBrush_NoStretch_NoTile_Alignment_TopLeft()
         {
             Decorator target = new Decorator
             {
@@ -81,7 +82,7 @@ public void VisualBrush_NoStretch_NoTile_Alignment_TopLeft()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -92,7 +93,7 @@ public void VisualBrush_NoStretch_NoTile_Alignment_TopLeft()
 #else
         [Fact]
 #endif
-        public void VisualBrush_NoStretch_NoTile_Alignment_Center()
+        public async Task VisualBrush_NoStretch_NoTile_Alignment_Center()
         {
             Decorator target = new Decorator
             {
@@ -112,12 +113,12 @@ public void VisualBrush_NoStretch_NoTile_Alignment_Center()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void VisualBrush_NoStretch_NoTile_Alignment_BottomRight()
+        public async Task VisualBrush_NoStretch_NoTile_Alignment_BottomRight()
         {
             Decorator target = new Decorator
             {
@@ -137,7 +138,7 @@ public void VisualBrush_NoStretch_NoTile_Alignment_BottomRight()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -148,7 +149,7 @@ public void VisualBrush_NoStretch_NoTile_Alignment_BottomRight()
 #else
         [Fact]
 #endif
-        public void VisualBrush_Fill_NoTile()
+        public async Task VisualBrush_Fill_NoTile()
         {
             Decorator target = new Decorator
             {
@@ -166,7 +167,7 @@ public void VisualBrush_Fill_NoTile()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -177,7 +178,7 @@ public void VisualBrush_Fill_NoTile()
 #else
         [Fact]
 #endif
-        public void VisualBrush_Uniform_NoTile()
+        public async Task VisualBrush_Uniform_NoTile()
         {
             Decorator target = new Decorator
             {
@@ -195,7 +196,7 @@ public void VisualBrush_Uniform_NoTile()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -206,7 +207,7 @@ public void VisualBrush_Uniform_NoTile()
 #else
         [Fact]
 #endif
-        public void VisualBrush_UniformToFill_NoTile()
+        public async Task VisualBrush_UniformToFill_NoTile()
         {
             Decorator target = new Decorator
             {
@@ -224,12 +225,12 @@ public void VisualBrush_UniformToFill_NoTile()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void VisualBrush_NoStretch_NoTile_BottomRightQuarterSource()
+        public async Task VisualBrush_NoStretch_NoTile_BottomRightQuarterSource()
         {
             Decorator target = new Decorator
             {
@@ -248,7 +249,7 @@ public void VisualBrush_NoStretch_NoTile_BottomRightQuarterSource()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -259,7 +260,7 @@ public void VisualBrush_NoStretch_NoTile_BottomRightQuarterSource()
 #else
         [Fact]
 #endif
-        public void VisualBrush_NoStretch_NoTile_BottomRightQuarterDest()
+        public async Task VisualBrush_NoStretch_NoTile_BottomRightQuarterDest()
         {
             Decorator target = new Decorator
             {
@@ -278,7 +279,7 @@ public void VisualBrush_NoStretch_NoTile_BottomRightQuarterDest()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -287,7 +288,7 @@ public void VisualBrush_NoStretch_NoTile_BottomRightQuarterDest()
 #else
         [Fact]
 #endif
-        public void VisualBrush_NoStretch_NoTile_BottomRightQuarterSource_BottomRightQuarterDest()
+        public async Task VisualBrush_NoStretch_NoTile_BottomRightQuarterSource_BottomRightQuarterDest()
         {
             Decorator target = new Decorator
             {
@@ -307,12 +308,12 @@ public void VisualBrush_NoStretch_NoTile_BottomRightQuarterSource_BottomRightQua
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void VisualBrush_NoStretch_Tile_BottomRightQuarterSource_CenterQuarterDest()
+        public async Task VisualBrush_NoStretch_Tile_BottomRightQuarterSource_CenterQuarterDest()
         {
             Decorator target = new Decorator
             {
@@ -332,7 +333,7 @@ public void VisualBrush_NoStretch_Tile_BottomRightQuarterSource_CenterQuarterDes
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -343,7 +344,7 @@ public void VisualBrush_NoStretch_Tile_BottomRightQuarterSource_CenterQuarterDes
 #else
         [Fact]
 #endif
-        public void VisualBrush_NoStretch_FlipX_TopLeftDest()
+        public async Task VisualBrush_NoStretch_FlipX_TopLeftDest()
         {
             Decorator target = new Decorator
             {
@@ -362,7 +363,7 @@ public void VisualBrush_NoStretch_FlipX_TopLeftDest()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -373,7 +374,7 @@ public void VisualBrush_NoStretch_FlipX_TopLeftDest()
 #else
         [Fact]
 #endif
-        public void VisualBrush_NoStretch_FlipY_TopLeftDest()
+        public async Task VisualBrush_NoStretch_FlipY_TopLeftDest()
         {
             Decorator target = new Decorator
             {
@@ -392,7 +393,7 @@ public void VisualBrush_NoStretch_FlipY_TopLeftDest()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -403,7 +404,7 @@ public void VisualBrush_NoStretch_FlipY_TopLeftDest()
 #else
         [Fact]
 #endif
-        public void VisualBrush_NoStretch_FlipXY_TopLeftDest()
+        public async Task VisualBrush_NoStretch_FlipXY_TopLeftDest()
         {
             Decorator target = new Decorator
             {
@@ -422,7 +423,53 @@ public void VisualBrush_NoStretch_FlipXY_TopLeftDest()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
+            CompareImages();
+        }
+
+#if AVALONIA_CAIRO
+        [Fact(Skip = "Font scaling currently broken on cairo")]
+#elif AVALONIA_SKIA_SKIP_FAIL
+        [Fact(Skip = "FIXME")]
+#else
+        [Fact]
+#endif
+        public async Task VisualBrush_InTree_Visual()
+        {
+            Border source;
+            Decorator target = new Decorator
+            {
+                Padding = new Thickness(8),
+                Width = 200,
+                Height = 200,
+                Child = new Grid
+                {
+                    RowDefinitions = new RowDefinitions("Auto,*"),
+                    Children =
+                    {
+                        (source = new Border
+                        {
+                            Background = Brushes.Yellow,
+                            HorizontalAlignment = HorizontalAlignment.Left,
+                            Child = new TextBlock
+                            {
+                                Text = "Visual"
+                            }
+                        }),
+                        new Border
+                        {
+                            Background = new VisualBrush
+                            {
+                                Stretch = Stretch.Uniform,
+                                Visual = source,
+                            },
+                            [Grid.RowProperty] = 1,
+                        }
+                    }
+                }
+            };
+
+            await RenderToFile(target);
             CompareImages();
         }
     }
diff --git a/tests/Avalonia.RenderTests/OpacityMaskTests.cs b/tests/Avalonia.RenderTests/OpacityMaskTests.cs
index b23f231f2e1..b49f04f3ee1 100644
--- a/tests/Avalonia.RenderTests/OpacityMaskTests.cs
+++ b/tests/Avalonia.RenderTests/OpacityMaskTests.cs
@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Text;
 using Xunit;
+using System.Threading.Tasks;
 
 #if AVALONIA_CAIRO
 namespace Avalonia.Cairo.RenderTests
@@ -22,7 +23,7 @@ public OpacityMaskTests()
         }
 
         [Fact]
-        public void Opacity_Mask_Masks_Element()
+        public async Task Opacity_Mask_Masks_Element()
         {
             var target = new Canvas
             {
@@ -53,7 +54,7 @@ public void Opacity_Mask_Masks_Element()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
     }
diff --git a/tests/Avalonia.RenderTests/Shapes/EllipseTests.cs b/tests/Avalonia.RenderTests/Shapes/EllipseTests.cs
index 67cc50cd581..9687e817e36 100644
--- a/tests/Avalonia.RenderTests/Shapes/EllipseTests.cs
+++ b/tests/Avalonia.RenderTests/Shapes/EllipseTests.cs
@@ -1,6 +1,7 @@
 // Copyright (c) The Avalonia Project. All rights reserved.
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
+using System.Threading.Tasks;
 using Avalonia.Controls;
 using Avalonia.Controls.Shapes;
 using Avalonia.Media;
@@ -22,7 +23,7 @@ public EllipseTests()
         }
 
         [Fact]
-        public void Circle_1px_Stroke()
+        public async Task Circle_1px_Stroke()
         {
             Decorator target = new Decorator
             {
@@ -36,7 +37,7 @@ public void Circle_1px_Stroke()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
     }
diff --git a/tests/Avalonia.RenderTests/Shapes/LineTests.cs b/tests/Avalonia.RenderTests/Shapes/LineTests.cs
index 80a4771c1f3..05974e75f14 100644
--- a/tests/Avalonia.RenderTests/Shapes/LineTests.cs
+++ b/tests/Avalonia.RenderTests/Shapes/LineTests.cs
@@ -1,6 +1,7 @@
 // Copyright (c) The Avalonia Project. All rights reserved.
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
+using System.Threading.Tasks;
 using Avalonia.Controls;
 using Avalonia.Controls.Shapes;
 using Avalonia.Media;
@@ -22,7 +23,7 @@ public LineTests()
         }
 
         [Fact]
-        public void Line_1px_Stroke()
+        public async Task Line_1px_Stroke()
         {
             Decorator target = new Decorator
             {
@@ -37,12 +38,12 @@ public void Line_1px_Stroke()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void Line_1px_Stroke_Reversed()
+        public async Task Line_1px_Stroke_Reversed()
         {
             Decorator target = new Decorator
             {
@@ -57,12 +58,12 @@ public void Line_1px_Stroke_Reversed()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void Line_1px_Stroke_Vertical()
+        public async Task Line_1px_Stroke_Vertical()
         {
             Decorator target = new Decorator
             {
@@ -77,7 +78,7 @@ public void Line_1px_Stroke_Vertical()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
     }
diff --git a/tests/Avalonia.RenderTests/Shapes/PathTests.cs b/tests/Avalonia.RenderTests/Shapes/PathTests.cs
index a9c70046511..0fc3246635f 100644
--- a/tests/Avalonia.RenderTests/Shapes/PathTests.cs
+++ b/tests/Avalonia.RenderTests/Shapes/PathTests.cs
@@ -15,6 +15,7 @@ namespace Avalonia.Skia.RenderTests
 namespace Avalonia.Direct2D1.RenderTests.Shapes
 #endif
 {
+    using System.Threading.Tasks;
     using Avalonia.Collections;
 
     public class PathTests : TestBase
@@ -29,7 +30,7 @@ public PathTests()
 #else
         [Fact]
 #endif
-        public void Line_Absolute()
+        public async Task Line_Absolute()
         {
             Decorator target = new Decorator
             {
@@ -45,7 +46,7 @@ public void Line_Absolute()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -54,7 +55,7 @@ public void Line_Absolute()
 #else
         [Fact]
 #endif
-        public void Line_Relative()
+        public async Task Line_Relative()
         {
             Decorator target = new Decorator
             {
@@ -70,7 +71,7 @@ public void Line_Relative()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -79,7 +80,7 @@ public void Line_Relative()
 #else
         [Fact]
 #endif
-        public void HorizontalLine_Absolute()
+        public async Task HorizontalLine_Absolute()
         {
             Decorator target = new Decorator
             {
@@ -95,7 +96,7 @@ public void HorizontalLine_Absolute()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -104,7 +105,7 @@ public void HorizontalLine_Absolute()
 #else
         [Fact]
 #endif
-        public void HorizontalLine_Relative()
+        public async Task HorizontalLine_Relative()
         {
             Decorator target = new Decorator
             {
@@ -120,7 +121,7 @@ public void HorizontalLine_Relative()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -129,7 +130,7 @@ public void HorizontalLine_Relative()
 #else
         [Fact]
 #endif
-        public void VerticalLine_Absolute()
+        public async Task VerticalLine_Absolute()
         {
             Decorator target = new Decorator
             {
@@ -145,7 +146,7 @@ public void VerticalLine_Absolute()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -154,7 +155,7 @@ public void VerticalLine_Absolute()
 #else
         [Fact]
 #endif
-        public void VerticalLine_Relative()
+        public async Task VerticalLine_Relative()
         {
             Decorator target = new Decorator
             {
@@ -170,7 +171,7 @@ public void VerticalLine_Relative()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -179,7 +180,7 @@ public void VerticalLine_Relative()
 #else
         [Fact]
 #endif
-        public void CubicBezier_Absolute()
+        public async Task CubicBezier_Absolute()
         {
             Decorator target = new Decorator
             {
@@ -196,7 +197,7 @@ public void CubicBezier_Absolute()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -205,7 +206,7 @@ public void CubicBezier_Absolute()
 #else
         [Fact]
 #endif
-        public void CubicBezier_Relative()
+        public async Task CubicBezier_Relative()
         {
             Decorator target = new Decorator
             {
@@ -222,7 +223,7 @@ public void CubicBezier_Relative()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -231,7 +232,7 @@ public void CubicBezier_Relative()
 #else
         [Fact]
 #endif
-        public void Arc_Absolute()
+        public async Task Arc_Absolute()
         {
             Decorator target = new Decorator
             {
@@ -248,7 +249,7 @@ public void Arc_Absolute()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -257,7 +258,7 @@ public void Arc_Absolute()
 #else
         [Fact]
 #endif
-        public void Arc_Relative()
+        public async Task Arc_Relative()
         {
             Decorator target = new Decorator
             {
@@ -274,12 +275,12 @@ public void Arc_Relative()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void Path_100px_Triangle_Centered()
+        public async Task Path_100px_Triangle_Centered()
         {
             Decorator target = new Decorator
             {
@@ -296,12 +297,12 @@ public void Path_100px_Triangle_Centered()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void Path_Tick_Scaled()
+        public async Task Path_Tick_Scaled()
         {
             Decorator target = new Decorator
             {
@@ -319,12 +320,12 @@ public void Path_Tick_Scaled()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void Path_Tick_Scaled_Stroke_8px()
+        public async Task Path_Tick_Scaled_Stroke_8px()
         {
             Decorator target = new Decorator
             {
@@ -342,12 +343,12 @@ public void Path_Tick_Scaled_Stroke_8px()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void Path_Expander_With_Border()
+        public async Task Path_Expander_With_Border()
         {
             Decorator target = new Decorator
             {
@@ -370,7 +371,7 @@ public void Path_Expander_With_Border()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -381,7 +382,7 @@ public void Path_Expander_With_Border()
 #else
         [Fact]
 #endif
-        public void Path_With_PenLineCap()
+        public async Task Path_With_PenLineCap()
         {
             Decorator target = new Decorator
             {
@@ -401,7 +402,7 @@ public void Path_With_PenLineCap()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
     }
diff --git a/tests/Avalonia.RenderTests/Shapes/PolygonTests.cs b/tests/Avalonia.RenderTests/Shapes/PolygonTests.cs
index 0f0debb92d2..415f0b4e859 100644
--- a/tests/Avalonia.RenderTests/Shapes/PolygonTests.cs
+++ b/tests/Avalonia.RenderTests/Shapes/PolygonTests.cs
@@ -1,6 +1,7 @@
 // Copyright (c) The Avalonia Project. All rights reserved.
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
+using System.Threading.Tasks;
 using Avalonia.Controls;
 using Avalonia.Controls.Shapes;
 using Avalonia.Media;
@@ -26,7 +27,7 @@ public PolygonTests()
 #else
         [Fact]
 #endif
-        public void Polygon_1px_Stroke()
+        public async Task Polygon_1px_Stroke()
         {
             Decorator target = new Decorator
             {
@@ -43,7 +44,7 @@ public void Polygon_1px_Stroke()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -52,7 +53,7 @@ public void Polygon_1px_Stroke()
 #else
         [Fact]
 #endif
-        public void Polygon_NonUniformFill()
+        public async Task Polygon_NonUniformFill()
         {
             Decorator target = new Decorator
             {
@@ -69,7 +70,7 @@ public void Polygon_NonUniformFill()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
     }
diff --git a/tests/Avalonia.RenderTests/Shapes/PolylineTests.cs b/tests/Avalonia.RenderTests/Shapes/PolylineTests.cs
index d8ebde5712a..684529dd4b8 100644
--- a/tests/Avalonia.RenderTests/Shapes/PolylineTests.cs
+++ b/tests/Avalonia.RenderTests/Shapes/PolylineTests.cs
@@ -1,6 +1,7 @@
 // Copyright (c) The Avalonia Project. All rights reserved.
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
+using System.Threading.Tasks;
 using Avalonia.Controls;
 using Avalonia.Controls.Shapes;
 using Avalonia.Media;
@@ -26,7 +27,7 @@ public PolylineTests()
 #else
         [Fact]
 #endif
-        public void Polyline_1px_Stroke()
+        public async Task Polyline_1px_Stroke()
         {
             var polylinePoints = new Point[] { new Point(0, 0), new Point(5, 0), new Point(6, -2), new Point(7, 3), new Point(8, -3),
                 new Point(9, 1), new Point(10, 0), new Point(15, 0) };
@@ -45,7 +46,7 @@ public void Polyline_1px_Stroke()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
@@ -54,7 +55,7 @@ public void Polyline_1px_Stroke()
 #else
         [Fact]
 #endif
-        public void Polyline_10px_Stroke_PenLineJoin()
+        public async Task Polyline_10px_Stroke_PenLineJoin()
         {
             var polylinePoints = new Point[] { new Point(0, 0), new Point(5, 0), new Point(6, -2), new Point(7, 3), new Point(8, -3),
                 new Point(9, 1), new Point(10, 0), new Point(15, 0) };
@@ -76,7 +77,7 @@ public void Polyline_10px_Stroke_PenLineJoin()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
     }
diff --git a/tests/Avalonia.RenderTests/Shapes/RectangleTests.cs b/tests/Avalonia.RenderTests/Shapes/RectangleTests.cs
index 1bd102b6767..5fa424103f8 100644
--- a/tests/Avalonia.RenderTests/Shapes/RectangleTests.cs
+++ b/tests/Avalonia.RenderTests/Shapes/RectangleTests.cs
@@ -1,6 +1,7 @@
 // Copyright (c) The Avalonia Project. All rights reserved.
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
+using System.Threading.Tasks;
 using Avalonia.Controls;
 using Avalonia.Controls.Shapes;
 using Avalonia.Media;
@@ -22,7 +23,7 @@ public RectangleTests()
         }
 
         [Fact]
-        public void Rectangle_1px_Stroke()
+        public async Task Rectangle_1px_Stroke()
         {
             Decorator target = new Decorator
             {
@@ -36,12 +37,12 @@ public void Rectangle_1px_Stroke()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void Rectangle_2px_Stroke()
+        public async Task Rectangle_2px_Stroke()
         {
             Decorator target = new Decorator
             {
@@ -55,12 +56,12 @@ public void Rectangle_2px_Stroke()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void Rectangle_Stroke_Fill()
+        public async Task Rectangle_Stroke_Fill()
         {
             Decorator target = new Decorator
             {
@@ -75,12 +76,12 @@ public void Rectangle_Stroke_Fill()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
 
         [Fact]
-        public void Rectangle_Stroke_Fill_ClipToBounds()
+        public async Task Rectangle_Stroke_Fill_ClipToBounds()
         {
             Decorator target = new Decorator
             {
@@ -96,7 +97,7 @@ public void Rectangle_Stroke_Fill_ClipToBounds()
                 }
             };
 
-            RenderToFile(target);
+            await RenderToFile(target);
             CompareImages();
         }
     }
diff --git a/tests/Avalonia.RenderTests/TestBase.cs b/tests/Avalonia.RenderTests/TestBase.cs
index 385cb052da1..2c07fcf38f9 100644
--- a/tests/Avalonia.RenderTests/TestBase.cs
+++ b/tests/Avalonia.RenderTests/TestBase.cs
@@ -9,6 +9,10 @@
 using Avalonia.Rendering;
 
 using Xunit;
+using Avalonia.Platform;
+using System.Threading.Tasks;
+using System;
+using System.Threading;
 
 #if AVALONIA_CAIRO
 using Avalonia.Cairo;
@@ -28,6 +32,9 @@ namespace Avalonia.Direct2D1.RenderTests
 {
     public class TestBase
     {
+        private static readonly TestThreadingInterface threadingInterface =
+            new TestThreadingInterface();
+
         static TestBase()
         {
 #if AVALONIA_CAIRO
@@ -37,6 +44,10 @@ static TestBase()
 #else
             Direct2D1Platform.Initialize();
 #endif
+            AvaloniaLocator.CurrentMutable
+                .Bind<IPlatformThreadingInterface>()
+                .ToConstant(threadingInterface);
+
         }
 
         public TestBase(string outputPath)
@@ -49,6 +60,8 @@ public TestBase(string outputPath)
             string testFiles = Path.GetFullPath(@"..\..\tests\TestFiles\Direct2D1");
 #endif
             OutputPath = Path.Combine(testFiles, outputPath);
+
+            threadingInterface.MainThread = Thread.CurrentThread;
         }
 
         public string OutputPath
@@ -56,14 +69,16 @@ public string OutputPath
             get;
         }
 
-        protected void RenderToFile(Control target, [CallerMemberName] string testName = "")
+        protected async Task RenderToFile(Control target, [CallerMemberName] string testName = "")
         {
             if (!Directory.Exists(OutputPath))
             {
                 Directory.CreateDirectory(OutputPath);
             }
 
-            string path = Path.Combine(OutputPath, testName + ".out.png");
+            var immediatePath = Path.Combine(OutputPath, testName + ".immediate.out.png");
+            var deferredPath = Path.Combine(OutputPath, testName + ".deferred.out.png");
+            var factory = AvaloniaLocator.Current.GetService<IPlatformRenderInterface>();
 
             using (RenderTargetBitmap bitmap = new RenderTargetBitmap(
                 (int)target.Width,
@@ -73,24 +88,89 @@ protected void RenderToFile(Control target, [CallerMemberName] string testName =
                 target.Measure(size);
                 target.Arrange(new Rect(size));
                 bitmap.Render(target);
-                bitmap.Save(path);
+                bitmap.Save(immediatePath);
+            }
+
+            using (var rtb = factory.CreateRenderTargetBitmap((int)target.Width, (int)target.Height, 96, 96))
+            using (var renderer = new DeferredRenderer(target, rtb))
+            {
+                Size size = new Size(target.Width, target.Height);
+                target.Measure(size);
+                target.Arrange(new Rect(size));
+                renderer.UnitTestUpdateScene();
+
+                // Do the deferred render on a background thread to expose any threading errors in
+                // the deferred rendering path.
+                await Task.Run((Action)renderer.UnitTestRender);
+
+                rtb.Save(deferredPath);
             }
         }
 
         protected void CompareImages([CallerMemberName] string testName = "")
         {
-            string expectedPath = Path.Combine(OutputPath, testName + ".expected.png");
-            string actualPath = Path.Combine(OutputPath, testName + ".out.png");
-            using (MagickImage expected = new MagickImage(expectedPath))
-            using (MagickImage actual = new MagickImage(actualPath))
+            var expectedPath = Path.Combine(OutputPath, testName + ".expected.png");
+            var immediatePath = Path.Combine(OutputPath, testName + ".immediate.out.png");
+            var deferredPath = Path.Combine(OutputPath, testName + ".deferred.out.png");
+
+            using (var expected = new MagickImage(expectedPath))
+            using (var immediate = new MagickImage(immediatePath))
+            using (var deferred = new MagickImage(deferredPath))
+            {
+                double immediateError = expected.Compare(immediate, ErrorMetric.RootMeanSquared);
+                double deferredError = expected.Compare(deferred, ErrorMetric.RootMeanSquared);
+
+                if (immediateError > 0.022)
+                {
+                    Assert.True(false, immediatePath + ": Error = " + immediateError);
+                }
+
+                if (deferredError > 0.022)
+                {
+                    Assert.True(false, deferredPath + ": Error = " + deferredError);
+                }
+            }
+        }
+
+        protected void CompareImagesNoRenderer([CallerMemberName] string testName = "")
+        {
+            var expectedPath = Path.Combine(OutputPath, testName + ".expected.png");
+            var actualPath = Path.Combine(OutputPath, testName + ".out.png");
+
+            using (var expected = new MagickImage(expectedPath))
+            using (var actual = new MagickImage(actualPath))
             {
-                double error = expected.Compare(actual, ErrorMetric.RootMeanSquared);
+                double immediateError = expected.Compare(actual, ErrorMetric.RootMeanSquared);
 
-                if (error > 0.022)
+                if (immediateError > 0.022)
                 {
-                    Assert.True(false, actualPath + ": Error = " + error);
+                    Assert.True(false, actualPath + ": Error = " + immediateError);
                 }
             }
         }
+
+        private class TestThreadingInterface : IPlatformThreadingInterface
+        {
+            public bool CurrentThreadIsLoopThread => MainThread.ManagedThreadId == Thread.CurrentThread.ManagedThreadId;
+
+            public Thread MainThread { get; set; }
+
+            public event Action Signaled;
+
+            public void RunLoop(CancellationToken cancellationToken)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Signal()
+            {
+                throw new NotImplementedException();
+            }
+
+            public IDisposable StartTimer(TimeSpan interval, Action tick)
+            {
+                throw new NotImplementedException();
+            }
+        }
     }
 }
diff --git a/tests/Avalonia.UnitTests/ImmediateDispatcher.cs b/tests/Avalonia.UnitTests/ImmediateDispatcher.cs
new file mode 100644
index 00000000000..4019e65bdfa
--- /dev/null
+++ b/tests/Avalonia.UnitTests/ImmediateDispatcher.cs
@@ -0,0 +1,32 @@
+using System;
+using System.Threading.Tasks;
+using Avalonia.Threading;
+
+namespace Avalonia.UnitTests
+{
+    /// <summary>
+    /// Immediately invokes dispatched jobs on the current thread.
+    /// </summary>
+    public class ImmediateDispatcher : IDispatcher
+    {
+        public bool CheckAccess()
+        {
+            return true;
+        }
+
+        public void InvokeAsync(Action action, DispatcherPriority priority = DispatcherPriority.Normal)
+        {
+            action();
+        }
+
+        public Task InvokeTaskAsync(Action action, DispatcherPriority priority = DispatcherPriority.Normal)
+        {
+            action();
+            return Task.FromResult<object>(null);
+        }
+
+        public void VerifyAccess()
+        {
+        }
+    }
+}
diff --git a/tests/Avalonia.UnitTests/MockRendererFactory.cs b/tests/Avalonia.UnitTests/MockRendererFactory.cs
deleted file mode 100644
index e62012b13cb..00000000000
--- a/tests/Avalonia.UnitTests/MockRendererFactory.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Avalonia.Rendering;
-
-namespace Avalonia.UnitTests
-{
-    public class MockRendererFactory : IRendererFactory
-    {
-        private readonly Func<IRenderRoot, IRenderLoop, IRenderer> _cb;
-
-        public MockRendererFactory(Func<IRenderRoot, IRenderLoop, IRenderer> cb = null)
-        {
-            _cb = cb;
-        }
-
-        public MockRendererFactory(IRenderer renderer) : this((_, __) => renderer)
-        {
-
-        }
-
-        public IRenderer CreateRenderer(IRenderRoot root, IRenderLoop renderLoop)
-        {
-            return _cb?.Invoke(root, renderLoop);
-        }
-    }
-}
diff --git a/tests/Avalonia.UnitTests/TestRoot.cs b/tests/Avalonia.UnitTests/TestRoot.cs
index 399870aef98..d64a4ff4ce2 100644
--- a/tests/Avalonia.UnitTests/TestRoot.cs
+++ b/tests/Avalonia.UnitTests/TestRoot.cs
@@ -5,6 +5,7 @@
 using Avalonia.Controls;
 using Avalonia.Input;
 using Avalonia.Layout;
+using Avalonia.Media;
 using Avalonia.Platform;
 using Avalonia.Rendering;
 using Avalonia.Styling;
@@ -12,7 +13,7 @@
 
 namespace Avalonia.UnitTests
 {
-    public class TestRoot : Decorator, IFocusScope, ILayoutRoot, INameScope, IRenderRoot, IStyleRoot
+    public class TestRoot : Decorator, IFocusScope, ILayoutRoot, IInputRoot, INameScope, IRenderRoot, IStyleRoot
     {
         private readonly NameScope _nameScope = new NameScope();
         private readonly IRenderTarget _renderTarget = Mock.Of<IRenderTarget>(
@@ -20,9 +21,6 @@ public class TestRoot : Decorator, IFocusScope, ILayoutRoot, INameScope, IRender
 
         public TestRoot()
         {
-            var rendererFactory = AvaloniaLocator.Current.GetService<IRendererFactory>();
-            var renderLoop = AvaloniaLocator.Current.GetService<IRenderLoop>();
-            Renderer = rendererFactory?.CreateRenderer(this, renderLoop);
         }
 
         event EventHandler<NameScopeEventArgs> INameScope.Registered
@@ -41,18 +39,30 @@ public event EventHandler<NameScopeEventArgs> Unregistered
 
         public int NameScopeUnregisteredSubscribers { get; private set; }
 
-        public Size ClientSize => new Size(100, 100);
+        public Size ClientSize { get; set; } = new Size(100, 100);
 
         public Size MaxClientSize { get; set; } = Size.Infinity;
 
         public double LayoutScaling => 1;
 
+        public double RenderScaling => 1;
+
         public ILayoutManager LayoutManager => AvaloniaLocator.Current.GetService<ILayoutManager>();
 
         public IRenderTarget RenderTarget => null;
 
         public IRenderer Renderer { get; set; }
 
+        public IAccessKeyHandler AccessKeyHandler => null;
+
+        public IKeyboardNavigationHandler KeyboardNavigationHandler => null;
+
+        public IInputElement PointerOverElement { get; set; }
+
+        public IMouseDevice MouseDevice { get; set; }
+
+        public bool ShowAccessKeys { get; set; }
+
         public IRenderTarget CreateRenderTarget() => _renderTarget;
 
         public void Invalidate(Rect rect)
diff --git a/tests/Avalonia.UnitTests/TestServices.cs b/tests/Avalonia.UnitTests/TestServices.cs
index 7e2d6d476cd..394dcbaa22d 100644
--- a/tests/Avalonia.UnitTests/TestServices.cs
+++ b/tests/Avalonia.UnitTests/TestServices.cs
@@ -23,9 +23,7 @@ public class TestServices
             assetLoader: new AssetLoader(),
             layoutManager: new LayoutManager(),
             platform: new AppBuilder().RuntimePlatform,
-            renderer: (_, __) => Mock.Of<IRenderer>(),
-            renderInterface: CreateRenderInterfaceMock(),
-            renderLoop: Mock.Of<IRenderLoop>(),
+            renderInterface: new MockPlatformRenderInterface(),
             standardCursorFactory: Mock.Of<IStandardCursorFactory>(),
             styler: new Styler(),
             theme: () => CreateDefaultTheme(),
@@ -33,20 +31,20 @@ public class TestServices
             windowingPlatform: new MockWindowingPlatform());
 
         public static readonly TestServices MockPlatformRenderInterface = new TestServices(
-            renderInterface: CreateRenderInterfaceMock());
+            renderInterface: new MockPlatformRenderInterface());
 
         public static readonly TestServices MockPlatformWrapper = new TestServices(
             platform: Mock.Of<IRuntimePlatform>());
 
-        public static readonly TestServices MockWindowingPlatform = new TestServices(
-                    windowingPlatform: new MockWindowingPlatform());
-
         public static readonly TestServices MockStyler = new TestServices(
             styler: Mock.Of<IStyler>());
 
         public static readonly TestServices MockThreadingInterface = new TestServices(
             threadingInterface: Mock.Of<IPlatformThreadingInterface>(x => x.CurrentThreadIsLoopThread == true));
 
+        public static readonly TestServices MockWindowingPlatform = new TestServices(
+            windowingPlatform: new MockWindowingPlatform());
+
         public static readonly TestServices RealFocus = new TestServices(
             focusManager: new FocusManager(),
             keyboardDevice: () => new KeyboardDevice(),
@@ -66,8 +64,8 @@ public TestServices(
             Func<IKeyboardDevice> keyboardDevice = null,
             IKeyboardNavigationHandler keyboardNavigation = null,
             ILayoutManager layoutManager = null,
+            Func<IMouseDevice> mouseDevice = null,
             IRuntimePlatform platform = null,
-            Func<IRenderRoot, IRenderLoop, IRenderer> renderer = null,
             IPlatformRenderInterface renderInterface = null,
             IRenderLoop renderLoop = null,
             IScheduler scheduler = null,
@@ -75,6 +73,7 @@ public TestServices(
             IStyler styler = null,
             Func<Styles> theme = null,
             IPlatformThreadingInterface threadingInterface = null,
+            IWindowImpl windowImpl = null,
             IWindowingPlatform windowingPlatform = null)
         {
             AssetLoader = assetLoader;
@@ -83,15 +82,15 @@ public TestServices(
             KeyboardDevice = keyboardDevice;
             KeyboardNavigation = keyboardNavigation;
             LayoutManager = layoutManager;
+            MouseDevice = mouseDevice;
             Platform = platform;
-            Renderer = renderer;
             RenderInterface = renderInterface;
-            RenderLoop = renderLoop;
             Scheduler = scheduler;
             StandardCursorFactory = standardCursorFactory;
             Styler = styler;
             Theme = theme;
             ThreadingInterface = threadingInterface;
+            WindowImpl = windowImpl;
             WindowingPlatform = windowingPlatform;
         }
 
@@ -101,15 +100,15 @@ public TestServices(
         public Func<IKeyboardDevice> KeyboardDevice { get; }
         public IKeyboardNavigationHandler KeyboardNavigation { get; }
         public ILayoutManager LayoutManager { get; }
+        public Func<IMouseDevice> MouseDevice { get; }
         public IRuntimePlatform Platform { get; }
-        public Func<IRenderRoot, IRenderLoop, IRenderer> Renderer { get; }
         public IPlatformRenderInterface RenderInterface { get; }
-        public IRenderLoop RenderLoop { get; }
         public IScheduler Scheduler { get; }
         public IStandardCursorFactory StandardCursorFactory { get; }
         public IStyler Styler { get; }
         public Func<Styles> Theme { get; }
         public IPlatformThreadingInterface ThreadingInterface { get; }
+        public IWindowImpl WindowImpl { get; }
         public IWindowingPlatform WindowingPlatform { get; }
 
         public TestServices With(
@@ -119,8 +118,8 @@ public TestServices With(
             Func<IKeyboardDevice> keyboardDevice = null,
             IKeyboardNavigationHandler keyboardNavigation = null,
             ILayoutManager layoutManager = null,
+            Func<IMouseDevice> mouseDevice = null,
             IRuntimePlatform platform = null,
-            Func<IRenderRoot, IRenderLoop, IRenderer> renderer = null,
             IPlatformRenderInterface renderInterface = null,
             IRenderLoop renderLoop = null,
             IScheduler scheduler = null,
@@ -138,16 +137,16 @@ public TestServices With(
                 keyboardDevice: keyboardDevice ?? KeyboardDevice,
                 keyboardNavigation: keyboardNavigation ?? KeyboardNavigation,
                 layoutManager: layoutManager ?? LayoutManager,
+                mouseDevice: mouseDevice ?? MouseDevice,
                 platform: platform ?? Platform,
-                renderer: renderer ?? Renderer,
                 renderInterface: renderInterface ?? RenderInterface,
-                renderLoop: renderLoop ?? RenderLoop,
                 scheduler: scheduler ?? Scheduler,
                 standardCursorFactory: standardCursorFactory ?? StandardCursorFactory,
                 styler: styler ?? Styler,
                 theme: theme ?? Theme,
                 threadingInterface: threadingInterface ?? ThreadingInterface,
-                windowingPlatform: windowingPlatform ?? WindowingPlatform);
+                windowingPlatform: windowingPlatform ?? WindowingPlatform,
+                windowImpl: windowImpl ?? WindowImpl);
         }
 
         private static Styles CreateDefaultTheme()
diff --git a/tests/Avalonia.UnitTests/TestTemplatedRoot.cs b/tests/Avalonia.UnitTests/TestTemplatedRoot.cs
index 73c9f370d6a..91e797fa87d 100644
--- a/tests/Avalonia.UnitTests/TestTemplatedRoot.cs
+++ b/tests/Avalonia.UnitTests/TestTemplatedRoot.cs
@@ -39,6 +39,8 @@ public event EventHandler<NameScopeEventArgs> Unregistered
 
         public double LayoutScaling => 1;
 
+        public double RenderScaling => 1;
+
         public ILayoutManager LayoutManager => AvaloniaLocator.Current.GetService<ILayoutManager>();
 
         public IRenderTarget RenderTarget => null;
diff --git a/tests/Avalonia.UnitTests/UnitTestApplication.cs b/tests/Avalonia.UnitTests/UnitTestApplication.cs
index 28577e96701..dfbcdbb9ae0 100644
--- a/tests/Avalonia.UnitTests/UnitTestApplication.cs
+++ b/tests/Avalonia.UnitTests/UnitTestApplication.cs
@@ -51,10 +51,9 @@ public override void RegisterServices()
                 .Bind<IKeyboardDevice>().ToConstant(Services.KeyboardDevice?.Invoke())
                 .Bind<IKeyboardNavigationHandler>().ToConstant(Services.KeyboardNavigation)
                 .Bind<ILayoutManager>().ToConstant(Services.LayoutManager)
+                .Bind<IMouseDevice>().ToConstant(Services.MouseDevice?.Invoke())
                 .Bind<IRuntimePlatform>().ToConstant(Services.Platform)
-                .Bind<IRendererFactory>().ToConstant(new RendererFactory(Services.Renderer))
                 .Bind<IPlatformRenderInterface>().ToConstant(Services.RenderInterface)
-                .Bind<IRenderLoop>().ToConstant(Services.RenderLoop)
                 .Bind<IPlatformThreadingInterface>().ToConstant(Services.ThreadingInterface)
                 .Bind<IScheduler>().ToConstant(Services.Scheduler)
                 .Bind<IStandardCursorFactory>().ToConstant(Services.StandardCursorFactory)
@@ -68,20 +67,5 @@ public override void RegisterServices()
                 Styles.AddRange(styles);
             }
         }
-
-        private class RendererFactory : IRendererFactory
-        {
-            Func<IRenderRoot, IRenderLoop, IRenderer> _func;
-
-            public RendererFactory(Func<IRenderRoot, IRenderLoop, IRenderer> func)
-            {
-                _func = func;
-            }
-
-            public IRenderer CreateRenderer(IRenderRoot root, IRenderLoop renderLoop)
-            {
-                return _func?.Invoke(root, renderLoop);
-            }
-        }
     }
 }
diff --git a/tests/Avalonia.Visuals.UnitTests/Avalonia.Visuals.UnitTests.v2.ncrunchproject b/tests/Avalonia.Visuals.UnitTests/Avalonia.Visuals.UnitTests.v2.ncrunchproject
deleted file mode 100644
index 30815b1937d..00000000000
--- a/tests/Avalonia.Visuals.UnitTests/Avalonia.Visuals.UnitTests.v2.ncrunchproject
+++ /dev/null
@@ -1,26 +0,0 @@
-<ProjectConfiguration>
-  <AutoDetectNugetBuildDependencies>true</AutoDetectNugetBuildDependencies>
-  <BuildPriority>1000</BuildPriority>
-  <CopyReferencedAssembliesToWorkspace>false</CopyReferencedAssembliesToWorkspace>
-  <ConsiderInconclusiveTestsAsPassing>false</ConsiderInconclusiveTestsAsPassing>
-  <PreloadReferencedAssemblies>false</PreloadReferencedAssemblies>
-  <AllowDynamicCodeContractChecking>true</AllowDynamicCodeContractChecking>
-  <AllowStaticCodeContractChecking>false</AllowStaticCodeContractChecking>
-  <AllowCodeAnalysis>false</AllowCodeAnalysis>
-  <IgnoreThisComponentCompletely>false</IgnoreThisComponentCompletely>
-  <RunPreBuildEvents>false</RunPreBuildEvents>
-  <RunPostBuildEvents>false</RunPostBuildEvents>
-  <PreviouslyBuiltSuccessfully>true</PreviouslyBuiltSuccessfully>
-  <InstrumentAssembly>true</InstrumentAssembly>
-  <PreventSigningOfAssembly>false</PreventSigningOfAssembly>
-  <AnalyseExecutionTimes>true</AnalyseExecutionTimes>
-  <DetectStackOverflow>true</DetectStackOverflow>
-  <IncludeStaticReferencesInWorkspace>true</IncludeStaticReferencesInWorkspace>
-  <DefaultTestTimeout>60000</DefaultTestTimeout>
-  <UseBuildConfiguration />
-  <UseBuildPlatform />
-  <ProxyProcessPath />
-  <UseCPUArchitecture>AutoDetect</UseCPUArchitecture>
-  <MSTestThreadApartmentState>STA</MSTestThreadApartmentState>
-  <BuildProcessArchitecture>x86</BuildProcessArchitecture>
-</ProjectConfiguration>
\ No newline at end of file
diff --git a/tests/Avalonia.Visuals.UnitTests/Rendering/DeferredRendererTests.cs b/tests/Avalonia.Visuals.UnitTests/Rendering/DeferredRendererTests.cs
new file mode 100644
index 00000000000..a9b27ed6018
--- /dev/null
+++ b/tests/Avalonia.Visuals.UnitTests/Rendering/DeferredRendererTests.cs
@@ -0,0 +1,293 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Media;
+using Avalonia.Platform;
+using Avalonia.Rendering;
+using Avalonia.Rendering.SceneGraph;
+using Avalonia.Threading;
+using Avalonia.UnitTests;
+using Avalonia.VisualTree;
+using Moq;
+using Xunit;
+
+namespace Avalonia.Visuals.UnitTests.Rendering
+{
+    public class DeferredRendererTests
+    {
+        [Fact]
+        public void First_Frame_Calls_UpdateScene_On_Dispatcher()
+        {
+            var loop = new Mock<IRenderLoop>();
+            var root = new TestRoot();
+
+            var dispatcher = new Mock<IDispatcher>();
+            dispatcher.Setup(x => x.InvokeAsync(It.IsAny<Action>(), DispatcherPriority.Render))
+                .Callback<Action, DispatcherPriority>((a, p) => a());
+
+            var target = new DeferredRenderer(
+                root,
+                loop.Object,
+                sceneBuilder: MockSceneBuilder(root).Object,
+                layerFactory: MockLayerFactory(root).Object,
+                dispatcher: dispatcher.Object);
+
+            target.Start();
+            RunFrame(loop);
+
+#if !NETCOREAPP1_1 // Delegate.Method is not available in netcoreapp1.1
+            dispatcher.Verify(x => 
+                x.InvokeAsync(
+                    It.Is<Action>(a => a.Method.Name == "UpdateScene"),
+                    DispatcherPriority.Render));
+#endif
+        }
+
+        [Fact]
+        public void First_Frame_Calls_SceneBuilder_UpdateAll()
+        {
+            var loop = new Mock<IRenderLoop>();
+            var root = new TestRoot();
+            var sceneBuilder = MockSceneBuilder(root);
+            var dispatcher = new ImmediateDispatcher();
+            var target = new DeferredRenderer(
+                root,
+                loop.Object,
+                sceneBuilder: sceneBuilder.Object,
+                layerFactory: MockLayerFactory(root).Object,
+                dispatcher: dispatcher);
+
+            target.Start();
+            RunFrame(loop);
+
+            sceneBuilder.Verify(x => x.UpdateAll(It.IsAny<Scene>()));
+        }
+
+        [Fact]
+        public void Frame_Does_Not_Call_SceneBuilder_If_No_Dirty_Controls()
+        {
+            var loop = new Mock<IRenderLoop>();
+            var root = new TestRoot();
+            var sceneBuilder = MockSceneBuilder(root);
+            var dispatcher = new ImmediateDispatcher();
+            var target = new DeferredRenderer(
+                root,
+                loop.Object,
+                sceneBuilder: sceneBuilder.Object,
+                layerFactory: MockLayerFactory(root).Object,
+                dispatcher: dispatcher);
+
+            target.Start();
+            IgnoreFirstFrame(loop, sceneBuilder);
+            RunFrame(loop);
+
+            sceneBuilder.Verify(x => x.UpdateAll(It.IsAny<Scene>()), Times.Never);
+            sceneBuilder.Verify(x => x.Update(It.IsAny<Scene>(), It.IsAny<Visual>()), Times.Never);
+        }
+
+        [Fact]
+        public void Should_Update_Dirty_Controls_In_Order()
+        {
+            var loop = new Mock<IRenderLoop>();
+            var dispatcher = new ImmediateDispatcher();
+
+            Border border;
+            Decorator decorator;
+            Canvas canvas;
+            var root = new TestRoot
+            {
+                Child = decorator = new Decorator
+                {
+                    Child = border = new Border
+                    {
+                        Child = canvas = new Canvas()
+                    }
+                }
+            };
+
+            var sceneBuilder = MockSceneBuilder(root);
+            var target = new DeferredRenderer(
+                root,
+                loop.Object,
+                sceneBuilder: sceneBuilder.Object,
+                layerFactory: MockLayerFactory(root).Object,
+                dispatcher: dispatcher);
+
+            target.Start();
+            IgnoreFirstFrame(loop, sceneBuilder);
+            target.AddDirty(border);
+            target.AddDirty(canvas);
+            target.AddDirty(root);
+            target.AddDirty(decorator);
+
+            var result = new List<IVisual>();
+            sceneBuilder.Setup(x => x.Update(It.IsAny<Scene>(), It.IsAny<IVisual>()))
+                .Callback<Scene, IVisual>((_, v) => result.Add(v));
+
+            RunFrame(loop);
+
+            Assert.Equal(new List<IVisual> { root, decorator, border, canvas }, result);
+        }
+
+        [Fact]
+        public void Frame_Should_Create_Layer_For_Root()
+        {
+            var loop = new Mock<IRenderLoop>();
+            var root = new TestRoot();
+            var rootLayer = new Mock<IRenderTargetBitmapImpl>();
+            var dispatcher = new ImmediateDispatcher();
+
+            var sceneBuilder = new Mock<ISceneBuilder>();
+            sceneBuilder.Setup(x => x.UpdateAll(It.IsAny<Scene>()))
+                .Callback<Scene>(scene =>
+                {
+                    scene.Size = root.ClientSize;
+                    scene.Layers.Add(root).Dirty.Add(new Rect(root.ClientSize));
+                });
+
+            var layers = new Mock<IRenderLayerFactory>();
+            layers.Setup(x => x.CreateLayer(root, root.ClientSize, 96, 96)).Returns(CreateLayer());
+
+            var renderInterface = new Mock<IPlatformRenderInterface>();
+
+            var target = new DeferredRenderer(
+                root,
+                loop.Object,
+                sceneBuilder: sceneBuilder.Object,
+                layerFactory: layers.Object,
+                dispatcher: dispatcher);
+
+            target.Start();
+            RunFrame(loop);
+
+            layers.Verify(x => x.CreateLayer(root, root.ClientSize, 96, 96));
+        }
+
+        [Fact]
+        public void Should_Create_And_Delete_Layers_For_Transparent_Controls()
+        {
+            Border border;
+            var root = new TestRoot
+            {
+                Width = 100,
+                Height = 100,
+                Child = new Border
+                {
+                    Background = Brushes.Red,
+                    Child = border = new Border
+                    {
+                        Background = Brushes.Green,
+                    }
+                }
+            };
+
+            root.Measure(Size.Infinity);
+            root.Arrange(new Rect(root.DesiredSize));
+
+            var loop = new Mock<IRenderLoop>();
+            var layerFactory = new MockRenderLayerFactory(new Dictionary<IVisual, IRenderTargetBitmapImpl>
+            {
+                { root, CreateLayer() },
+                { border, CreateLayer() },
+            });
+
+            var target = new DeferredRenderer(
+                root, 
+                loop.Object,
+                layerFactory: layerFactory,
+                dispatcher: new ImmediateDispatcher());
+            root.Renderer = target;
+
+            target.Start();
+            RunFrame(loop);
+
+            var rootContext = layerFactory.GetMockDrawingContext(root);
+            var borderContext = layerFactory.GetMockDrawingContext(border);
+
+            rootContext.Verify(x => x.FillRectangle(Brushes.Red, new Rect(0, 0, 100, 100), 0), Times.Once);
+            rootContext.Verify(x => x.FillRectangle(Brushes.Green, new Rect(0, 0, 100, 100), 0), Times.Once);
+            borderContext.Verify(x => x.FillRectangle(It.IsAny<IBrush>(), It.IsAny<Rect>(), It.IsAny<float>()), Times.Never);
+
+            rootContext.ResetCalls();
+            borderContext.ResetCalls();
+            border.Opacity = 0.5;
+            RunFrame(loop);
+
+            rootContext.Verify(x => x.FillRectangle(Brushes.Red, new Rect(0, 0, 100, 100), 0), Times.Once);
+            rootContext.Verify(x => x.FillRectangle(Brushes.Green, new Rect(0, 0, 100, 100), 0), Times.Never);
+            borderContext.Verify(x => x.FillRectangle(Brushes.Green, new Rect(0, 0, 100, 100), 0), Times.Once);
+
+            rootContext.ResetCalls();
+            borderContext.ResetCalls();
+            border.Opacity = 1;
+            RunFrame(loop);
+
+            layerFactory.GetMockBitmap(border).Verify(x => x.Dispose());
+            rootContext.Verify(x => x.FillRectangle(Brushes.Red, new Rect(0, 0, 100, 100), 0), Times.Once);
+            rootContext.Verify(x => x.FillRectangle(Brushes.Green, new Rect(0, 0, 100, 100), 0), Times.Once);
+            borderContext.Verify(x => x.FillRectangle(It.IsAny<IBrush>(), It.IsAny<Rect>(), It.IsAny<float>()), Times.Never);
+        }
+
+        private void IgnoreFirstFrame(Mock<IRenderLoop> loop, Mock<ISceneBuilder> sceneBuilder)
+        {
+            RunFrame(loop);
+            sceneBuilder.ResetCalls();
+        }
+
+        private void RunFrame(Mock<IRenderLoop> loop)
+        {
+            loop.Raise(x => x.Tick += null, EventArgs.Empty);
+        }
+
+        private IRenderTargetBitmapImpl CreateLayer()
+        {
+            return Mock.Of<IRenderTargetBitmapImpl>(x =>
+                x.CreateDrawingContext(It.IsAny<IVisualBrushRenderer>()) == Mock.Of<IDrawingContextImpl>());
+        }
+
+        private Mock<IRenderLayerFactory> MockLayerFactory(IRenderRoot root)
+        {
+            var result = new Mock<IRenderLayerFactory>();
+            result.Setup(x => x.CreateLayer(root, root.ClientSize, 96, 96)).Returns(CreateLayer());
+            return result;
+        }
+
+        private Mock<ISceneBuilder> MockSceneBuilder(IRenderRoot root)
+        {
+            var result = new Mock<ISceneBuilder>();
+            result.Setup(x => x.UpdateAll(It.IsAny<Scene>()))
+                .Callback<Scene>(x => x.Layers.Add(root).Dirty.Add(new Rect(root.ClientSize)));
+            return result;
+        }
+
+        private class MockRenderLayerFactory : IRenderLayerFactory
+        {
+            private IDictionary<IVisual, IRenderTargetBitmapImpl> _layers;
+
+            public MockRenderLayerFactory(IDictionary<IVisual, IRenderTargetBitmapImpl> layers)
+            {
+                _layers = layers;
+            }
+
+            public IRenderTargetBitmapImpl CreateLayer(
+                IVisual layerRoot,
+                Size size,
+                double dpiX,
+                double dpiY)
+            {
+                return _layers[layerRoot];
+            }
+
+            public Mock<IRenderTargetBitmapImpl> GetMockBitmap(IVisual layerRoot)
+            {
+                return Mock.Get(_layers[layerRoot]);
+            }
+
+            public Mock<IDrawingContextImpl> GetMockDrawingContext(IVisual layerRoot)
+            {
+                return Mock.Get(_layers[layerRoot].CreateDrawingContext(null));
+            }
+        }
+    }
+}
diff --git a/tests/Avalonia.Visuals.UnitTests/Rendering/DeferredRendererTests_HitTesting.cs b/tests/Avalonia.Visuals.UnitTests/Rendering/DeferredRendererTests_HitTesting.cs
new file mode 100644
index 00000000000..1044c1f2a36
--- /dev/null
+++ b/tests/Avalonia.Visuals.UnitTests/Rendering/DeferredRendererTests_HitTesting.cs
@@ -0,0 +1,508 @@
+// Copyright (c) The Avalonia Project. All rights reserved.
+// Licensed under the MIT license. See licence.md file in the project root for full license information.
+
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Controls.Presenters;
+using Avalonia.Layout;
+using Avalonia.Media;
+using Avalonia.Platform;
+using Avalonia.Rendering;
+using Avalonia.UnitTests;
+using Avalonia.VisualTree;
+using Moq;
+using Xunit;
+using System;
+using Avalonia.Controls.Shapes;
+
+namespace Avalonia.Visuals.UnitTests.Rendering
+{
+    public class DeferredRendererTests_HitTesting
+    {
+        [Fact]
+        public void HitTest_Should_Find_Controls_At_Point()
+        {
+            using (TestApplication())
+            {
+                var root = new TestRoot
+                {
+                    Width = 200,
+                    Height = 200,
+                    Child = new Border
+                    {
+                        Width = 100,
+                        Height = 100,
+                        Background = Brushes.Red,
+                        HorizontalAlignment = HorizontalAlignment.Center,
+                        VerticalAlignment = VerticalAlignment.Center
+                    }
+                };
+
+                root.Renderer = new DeferredRenderer(root, null);
+                root.Measure(Size.Infinity);
+                root.Arrange(new Rect(root.DesiredSize));
+
+                var result = root.Renderer.HitTest(new Point(100, 100), null);
+
+                Assert.Equal(new[] { root.Child }, result);
+            }
+        }
+
+        [Fact]
+        public void HitTest_Should_Not_Find_Empty_Controls_At_Point()
+        {
+            using (TestApplication())
+            {
+                var root = new TestRoot
+                {
+                    Width = 200,
+                    Height = 200,
+                    Child = new Border
+                    {
+                        Width = 100,
+                        Height = 100,
+                        HorizontalAlignment = HorizontalAlignment.Center,
+                        VerticalAlignment = VerticalAlignment.Center
+                    }
+                };
+
+                root.Renderer = new DeferredRenderer(root, null);
+                root.Measure(Size.Infinity);
+                root.Arrange(new Rect(root.DesiredSize));
+
+                var result = root.Renderer.HitTest(new Point(100, 100), null);
+
+                Assert.Empty(result);
+            }
+        }
+
+        [Fact]
+        public void HitTest_Should_Not_Find_Invisible_Controls_At_Point()
+        {
+            using (TestApplication())
+            {
+                Border visible;
+                var root = new TestRoot
+                {
+                    Width = 200,
+                    Height = 200,
+                    Child = new Border
+                    {
+                        Width = 100,
+                        Height = 100,
+                        Background = Brushes.Red,
+                        HorizontalAlignment = HorizontalAlignment.Center,
+                        VerticalAlignment = VerticalAlignment.Center,
+                        IsVisible = false,
+                        Child = visible = new Border
+                        {
+                            Background = Brushes.Red,
+                            HorizontalAlignment = HorizontalAlignment.Stretch,
+                            VerticalAlignment = VerticalAlignment.Stretch,
+                        }
+                    }
+                };
+
+                root.Renderer = new DeferredRenderer(root, null);
+                root.Measure(Size.Infinity);
+                root.Arrange(new Rect(root.DesiredSize));
+
+                var result = root.Renderer.HitTest(new Point(100, 100), null);
+
+                Assert.Empty(result);
+            }
+        }
+
+        [Fact]
+        public void HitTest_Should_Not_Find_Control_Outside_Point()
+        {
+            using (TestApplication())
+            {
+                var root = new TestRoot
+                {
+                    Width = 200,
+                    Height = 200,
+                    Child = new Border
+                    {
+                        Width = 100,
+                        Height = 100,
+                        Background = Brushes.Red,
+                        HorizontalAlignment = HorizontalAlignment.Center,
+                        VerticalAlignment = VerticalAlignment.Center
+                    }
+                };
+
+                root.Renderer = new DeferredRenderer(root, null);
+                root.Measure(Size.Infinity);
+                root.Arrange(new Rect(root.DesiredSize));
+
+                var result = root.Renderer.HitTest(new Point(10, 10), null);
+
+                Assert.Empty(result);
+            }
+        }
+
+        [Fact]
+        public void HitTest_Should_Return_Top_Controls_First()
+        {
+            using (TestApplication())
+            {
+                Panel container;
+                var root = new TestRoot
+                {
+                    Child = container = new Panel
+                    {
+                        Width = 200,
+                        Height = 200,
+                        Children = new Controls.Controls
+                        {
+                            new Border
+                            {
+                                Width = 100,
+                                Height = 100,
+                                Background = Brushes.Red,
+                                HorizontalAlignment = HorizontalAlignment.Center,
+                                VerticalAlignment = VerticalAlignment.Center
+                            },
+                            new Border
+                            {
+                                Width = 50,
+                                Height = 50,
+                                Background = Brushes.Red,
+                                HorizontalAlignment = HorizontalAlignment.Center,
+                                VerticalAlignment = VerticalAlignment.Center
+                            }
+                        }
+                    }
+                };
+
+                root.Renderer = new DeferredRenderer(root, null);
+                root.Measure(Size.Infinity);
+                root.Arrange(new Rect(container.DesiredSize));
+
+                var result = root.Renderer.HitTest(new Point(100, 100), null);
+
+                Assert.Equal(new[] { container.Children[1], container.Children[0] }, result);
+            }
+        }
+
+        [Fact]
+        public void HitTest_Should_Return_Top_Controls_First_With_ZIndex()
+        {
+            using (TestApplication())
+            {
+                Panel container;
+                var root = new TestRoot
+                {
+                    Child = container = new Panel
+                    {
+                        Width = 200,
+                        Height = 200,
+                        Children = new Controls.Controls
+                        {
+                            new Border
+                            {
+                                Width = 100,
+                                Height = 100,
+                                ZIndex = 1,
+                                Background = Brushes.Red,
+                                HorizontalAlignment = HorizontalAlignment.Center,
+                                VerticalAlignment = VerticalAlignment.Center
+                            },
+                            new Border
+                            {
+                                Width = 50,
+                                Height = 50,
+                                Background = Brushes.Red,
+                                HorizontalAlignment = HorizontalAlignment.Center,
+                                VerticalAlignment = VerticalAlignment.Center
+                            },
+                            new Border
+                            {
+                                Width = 75,
+                                Height = 75,
+                                ZIndex = 2,
+                                Background = Brushes.Red,
+                                HorizontalAlignment = HorizontalAlignment.Center,
+                                VerticalAlignment = VerticalAlignment.Center
+                            }
+                        }
+                    }
+                };
+
+                root.Renderer = new DeferredRenderer(root, null);
+                root.Measure(Size.Infinity);
+                root.Arrange(new Rect(container.DesiredSize));
+
+                var result = root.Renderer.HitTest(new Point(100, 100), null);
+
+                Assert.Equal(new[] { container.Children[2], container.Children[0], container.Children[1] }, result);
+            }
+        }
+
+        [Fact]
+        public void HitTest_Should_Find_Control_Translated_Outside_Parent_Bounds()
+        {
+            using (TestApplication())
+            {
+                Border target;
+                Panel container;
+                var root = new TestRoot
+                {
+                    Child = container = new Panel
+                    {
+                        Width = 200,
+                        Height = 200,
+                        Background = Brushes.Red,
+                        ClipToBounds = false,
+                        Children = new Controls.Controls
+                        {
+                            new Border
+                            {
+                                Width = 100,
+                                Height = 100,
+                                ZIndex = 1,
+                                Background = Brushes.Red,
+                                HorizontalAlignment = HorizontalAlignment.Left,
+                                VerticalAlignment = VerticalAlignment.Top,
+                                Child = target = new Border
+                                {
+                                    Width = 50,
+                                    Height = 50,
+                                    Background = Brushes.Red,
+                                    HorizontalAlignment = HorizontalAlignment.Left,
+                                    VerticalAlignment = VerticalAlignment.Top,
+                                    RenderTransform = new TranslateTransform(110, 110),
+                                }
+                            },
+                        }
+                    }
+                };
+
+                root.Renderer = new DeferredRenderer(root, null);
+                container.Measure(Size.Infinity);
+                container.Arrange(new Rect(container.DesiredSize));
+
+                var result = root.Renderer.HitTest(new Point(120, 120), null);
+
+                Assert.Equal(new IVisual[] { target, container }, result);
+            }
+        }
+
+        [Fact]
+        public void HitTest_Should_Not_Find_Control_Outside_Parent_Bounds_When_Clipped()
+        {
+            using (TestApplication())
+            {
+                Border target;
+                Panel container;
+                var root = new TestRoot
+                {
+                    Child = container = new Panel
+                    {
+                        Width = 100,
+                        Height = 200,
+                        Background = Brushes.Red,
+                        Children = new Controls.Controls
+                        {
+                            new Panel()
+                            {
+                                Width = 100,
+                                Height = 100,
+                                Background = Brushes.Red,
+                                Margin = new Thickness(0, 100, 0, 0),
+                                ClipToBounds = true,
+                                Children = new Controls.Controls
+                                {
+                                    (target = new Border()
+                                    {
+                                        Width = 100,
+                                        Height = 100,
+                                        Background = Brushes.Red,
+                                        Margin = new Thickness(0, -100, 0, 0)
+                                    })
+                                }
+                            }
+                        }
+                    }
+                };
+
+                root.Renderer = new DeferredRenderer(root, null);
+                root.Measure(Size.Infinity);
+                root.Arrange(new Rect(container.DesiredSize));
+
+                var result = root.Renderer.HitTest(new Point(50, 50), null);
+
+                Assert.Equal(new[] { container }, result);
+            }
+        }
+
+        [Fact]
+        public void HitTest_Should_Not_Find_Control_Outside_Scroll_Viewport()
+        {
+            using (TestApplication())
+            {
+                Border target;
+                Border item1;
+                Border item2;
+                ScrollContentPresenter scroll;
+                Panel container;
+                var root = new TestRoot
+                {
+                    Child = container = new Panel
+                    {
+                        Width = 100,
+                        Height = 200,
+                        Background = Brushes.Red,
+                        Children = new Controls.Controls
+                        {
+                            (target = new Border()
+                            {
+                                Name = "b1",
+                                Width = 100,
+                                Height = 100,
+                                Background = Brushes.Red,
+                            }),
+                            new Border()
+                            {
+                                Name = "b2",
+                                Width = 100,
+                                Height = 100,
+                                Background = Brushes.Red,
+                                Margin = new Thickness(0, 100, 0, 0),
+                                Child = scroll = new ScrollContentPresenter()
+                                {
+                                    Content = new StackPanel()
+                                    {
+                                        Children = new Controls.Controls
+                                        {
+                                            (item1 = new Border()
+                                            {
+                                                Name = "b3",
+                                                Width = 100,
+                                                Height = 100,
+                                                Background = Brushes.Red,
+                                            }),
+                                            (item2 = new Border()
+                                            {
+                                                Name = "b4",
+                                                Width = 100,
+                                                Height = 100,
+                                                Background = Brushes.Red,
+                                            }),
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                };
+
+                scroll.UpdateChild();
+
+                root.Renderer = new DeferredRenderer(root, null);
+                root.Measure(Size.Infinity);
+                root.Arrange(new Rect(container.DesiredSize));
+
+                var result = root.Renderer.HitTest(new Point(50, 150), null).First();
+
+                Assert.Equal(item1, result);
+
+                result = root.Renderer.HitTest(new Point(50, 50), null).First();
+
+                Assert.Equal(target, result);
+
+                scroll.Offset = new Vector(0, 100);
+
+                // We don't have LayoutManager set up so do the layout pass manually.
+                scroll.Parent.InvalidateArrange();
+                container.InvalidateArrange();
+                container.Arrange(new Rect(container.DesiredSize));
+
+                result = root.Renderer.HitTest(new Point(50, 150), null).First();
+                Assert.Equal(item2, result);
+
+                result = root.Renderer.HitTest(new Point(50, 50), null).First();
+                Assert.Equal(target, result);
+            }
+        }
+
+        [Fact]
+        public void HitTest_Should_Not_Find_Path_When_Outside_Fill()
+        {
+            using (TestApplication())
+            {
+                Path path;
+                var root = new TestRoot
+                {
+                    Width = 200,
+                    Height = 200,
+                    Child = path = new Path
+                    {
+                        Width = 200,
+                        Height = 200,
+                        Fill = Brushes.Red,
+                        Data = StreamGeometry.Parse("M100,0 L0,100 100,100")
+                    }
+                };
+
+                root.Renderer = new DeferredRenderer(root, null);
+                root.Measure(Size.Infinity);
+                root.Arrange(new Rect(root.DesiredSize));
+
+                var context = new DrawingContext(Mock.Of<IDrawingContextImpl>());
+
+                var result = root.Renderer.HitTest(new Point(100, 100), null);
+                Assert.Equal(new[] { path }, result);
+
+                result = root.Renderer.HitTest(new Point(10, 10), null);
+                Assert.Empty(result);
+            }
+        }
+
+        [Fact]
+        public void HitTest_Should_Respect_Geometry_Clip()
+        {
+            using (TestApplication())
+            {
+                Border border;
+                Canvas canvas;
+                var root = new TestRoot
+                {
+                    Width = 400,
+                    Height = 400,
+                    Child = border = new Border
+                    {
+                        Background = Brushes.Red,
+                        Clip = StreamGeometry.Parse("M100,0 L0,100 100,100"),
+                        Width = 200,
+                        Height = 200,
+                        Child = canvas = new Canvas
+                        {
+                            Background = Brushes.Yellow,
+                            Margin = new Thickness(10),
+                        }
+                    }
+                };
+
+                root.Renderer = new DeferredRenderer(root, null);
+                root.Measure(Size.Infinity);
+                root.Arrange(new Rect(root.DesiredSize));
+                Assert.Equal(new Rect(100, 100, 200, 200), border.Bounds);
+
+                var context = new DrawingContext(Mock.Of<IDrawingContextImpl>());
+
+                var result = root.Renderer.HitTest(new Point(200, 200), null);
+                Assert.Equal(new IVisual[] { canvas, border }, result);
+
+                result = root.Renderer.HitTest(new Point(110, 110), null);
+                Assert.Empty(result);
+            }
+        }
+
+        private IDisposable TestApplication()
+        {
+            return UnitTestApplication.Start(TestServices.MockPlatformRenderInterface);
+        }
+    }
+}
diff --git a/tests/Avalonia.Visuals.UnitTests/Rendering/ImmediateRendererTests_HitTesting.cs b/tests/Avalonia.Visuals.UnitTests/Rendering/ImmediateRendererTests_HitTesting.cs
index fa53cba9387..2c3e9bf11a5 100644
--- a/tests/Avalonia.Visuals.UnitTests/Rendering/ImmediateRendererTests_HitTesting.cs
+++ b/tests/Avalonia.Visuals.UnitTests/Rendering/ImmediateRendererTests_HitTesting.cs
@@ -35,6 +35,7 @@ public void HitTest_Should_Find_Controls_At_Point()
                     }
                 };
 
+                root.Renderer = new ImmediateRenderer(root);
                 root.Measure(Size.Infinity);
                 root.Arrange(new Rect(root.DesiredSize));
                 root.Renderer.Paint(new Rect(root.ClientSize));
@@ -72,6 +73,7 @@ public void HitTest_Should_Not_Find_Invisible_Controls_At_Point()
                     }
                 };
 
+                root.Renderer = new ImmediateRenderer(root);
                 root.Measure(Size.Infinity);
                 root.Arrange(new Rect(root.DesiredSize));
                 root.Renderer.Paint(new Rect(root.ClientSize));
@@ -101,6 +103,7 @@ public void HitTest_Should_Not_Find_Control_Outside_Point()
                     }
                 };
 
+                root.Renderer = new ImmediateRenderer(root);
                 root.Measure(Size.Infinity);
                 root.Arrange(new Rect(root.DesiredSize));
                 root.Renderer.Paint(new Rect(root.ClientSize));
@@ -145,6 +148,7 @@ public void HitTest_Should_Return_Top_Controls_First()
                     }
                 };
 
+                root.Renderer = new ImmediateRenderer(root);
                 root.Measure(Size.Infinity);
                 root.Arrange(new Rect(container.DesiredSize));
                 root.Renderer.Paint(new Rect(root.ClientSize));
@@ -199,6 +203,7 @@ public void HitTest_Should_Return_Top_Controls_First_With_ZIndex()
                     }
                 };
 
+                root.Renderer = new ImmediateRenderer(root);
                 root.Measure(Size.Infinity);
                 root.Arrange(new Rect(container.DesiredSize));
                 root.Renderer.Paint(new Rect(root.ClientSize));
@@ -257,6 +262,7 @@ public void HitTest_Should_Find_Control_Translated_Outside_Parent_Bounds()
                     }
                 };
 
+                root.Renderer = new ImmediateRenderer(root);
                 container.Measure(Size.Infinity);
                 container.Arrange(new Rect(container.DesiredSize));
                 root.Renderer.Paint(new Rect(root.ClientSize));
@@ -305,6 +311,7 @@ public void HitTest_Should_Not_Find_Control_Outside_Parent_Bounds_When_Clipped()
                     }
                 };
 
+                root.Renderer = new ImmediateRenderer(root);
                 root.Measure(Size.Infinity);
                 root.Arrange(new Rect(container.DesiredSize));
                 root.Renderer.Paint(new Rect(root.ClientSize));
@@ -378,6 +385,7 @@ public void HitTest_Should_Not_Find_Control_Outside_Scroll_Viewport()
 
                 scroll.UpdateChild();
 
+                root.Renderer = new ImmediateRenderer(root);
                 root.Measure(Size.Infinity);
                 root.Arrange(new Rect(container.DesiredSize));
                 root.Renderer.Paint(new Rect(root.ClientSize));
@@ -408,10 +416,7 @@ public void HitTest_Should_Not_Find_Control_Outside_Scroll_Viewport()
 
         private IDisposable TestApplication()
         {
-            return UnitTestApplication.Start(
-                new TestServices(
-                    renderInterface: new MockPlatformRenderInterface(),
-                    renderer: (root, loop) => new ImmediateRenderer(root)));
+            return UnitTestApplication.Start(TestServices.MockPlatformRenderInterface);
         }
     }
 }
diff --git a/tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/DeferredDrawingContextImplTests.cs b/tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/DeferredDrawingContextImplTests.cs
new file mode 100644
index 00000000000..19067757832
--- /dev/null
+++ b/tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/DeferredDrawingContextImplTests.cs
@@ -0,0 +1,195 @@
+using System;
+using System.Linq;
+using Avalonia.Media;
+using Avalonia.Rendering.SceneGraph;
+using Avalonia.UnitTests;
+using Avalonia.VisualTree;
+using Moq;
+using Xunit;
+
+namespace Avalonia.Visuals.UnitTests.Rendering.SceneGraph
+{
+    public class DeferredDrawingContextImplTests
+    {
+        [Fact]
+        public void Should_Add_VisualNode()
+        {
+            var parent = new VisualNode(new TestRoot(), null);
+            var child = new VisualNode(Mock.Of<IVisual>(), null);
+            var layers = new SceneLayers(parent.Visual);
+            var target = new DeferredDrawingContextImpl(null, layers);
+
+            target.BeginUpdate(parent);
+            target.BeginUpdate(child);
+
+            Assert.Equal(1, parent.Children.Count);
+            Assert.Same(child, parent.Children[0]);
+        }
+
+        [Fact]
+        public void Should_Not_Replace_Identical_VisualNode()
+        {
+            var parent = new VisualNode(new TestRoot(), null);
+            var child = new VisualNode(Mock.Of<IVisual>(), null);
+            var layers = new SceneLayers(parent.Visual);
+
+            parent.AddChild(child);
+
+            var target = new DeferredDrawingContextImpl(null, layers);
+
+            target.BeginUpdate(parent);
+            target.BeginUpdate(child);
+
+            Assert.Equal(1, parent.Children.Count);
+            Assert.Same(child, parent.Children[0]);
+        }
+
+        [Fact]
+        public void Should_Replace_Different_VisualNode()
+        {
+            var parent = new VisualNode(new TestRoot(), null);
+            var child1 = new VisualNode(Mock.Of<IVisual>(), null);
+            var child2 = new VisualNode(Mock.Of<IVisual>(), null);
+            var layers = new SceneLayers(parent.Visual);
+
+            parent.AddChild(child1);
+
+            var target = new DeferredDrawingContextImpl(null, layers);
+
+            target.BeginUpdate(parent);
+            target.BeginUpdate(child2);
+
+            Assert.Equal(1, parent.Children.Count);
+            Assert.Same(child2, parent.Children[0]);
+        }
+
+        [Fact]
+        public void TrimChildren_Should_Trim_Children()
+        {
+            var root = new TestRoot();
+            var node = new VisualNode(root, null) { LayerRoot = root };
+
+            node.AddChild(new VisualNode(Mock.Of<IVisual>(), node) { LayerRoot = root });
+            node.AddChild(new VisualNode(Mock.Of<IVisual>(), node) { LayerRoot = root });
+            node.AddChild(new VisualNode(Mock.Of<IVisual>(), node) { LayerRoot = root });
+            node.AddChild(new VisualNode(Mock.Of<IVisual>(), node) { LayerRoot = root });
+
+            var layers = new SceneLayers(root);
+            var target = new DeferredDrawingContextImpl(null, layers);
+            var child1 = new VisualNode(Mock.Of<IVisual>(), null) { LayerRoot = root };
+            var child2 = new VisualNode(Mock.Of<IVisual>(), null) { LayerRoot = root };
+
+            target.BeginUpdate(node);
+            using (target.BeginUpdate(child1)) { }
+            using (target.BeginUpdate(child2)) { }
+            target.TrimChildren();
+
+            Assert.Equal(2, node.Children.Count);
+        }
+
+        [Fact]
+        public void Should_Add_DrawOperations()
+        {
+            var node = new VisualNode(new TestRoot(), null);
+            var layers = new SceneLayers(node.Visual);
+            var target = new DeferredDrawingContextImpl(null, layers);
+
+            node.LayerRoot = node.Visual;
+
+            using (target.BeginUpdate(node))
+            {
+                target.FillRectangle(Brushes.Red, new Rect(0, 0, 100, 100));
+                target.DrawRectangle(new Pen(Brushes.Green, 1), new Rect(0, 0, 100, 100));
+            }
+
+            Assert.Equal(2, node.DrawOperations.Count);
+            Assert.IsType<RectangleNode>(node.DrawOperations[0]);
+            Assert.IsType<RectangleNode>(node.DrawOperations[1]);
+        }
+
+        [Fact]
+        public void Should_Not_Replace_Identical_DrawOperation()
+        {
+            var node = new VisualNode(new TestRoot(), null);
+            var operation = new RectangleNode(Matrix.Identity, Brushes.Red, null, new Rect(0, 0, 100, 100), 0);
+            var layers = new SceneLayers(node.Visual);
+            var target = new DeferredDrawingContextImpl(null, layers);
+
+            node.LayerRoot = node.Visual;
+            node.AddDrawOperation(operation);
+
+            using (target.BeginUpdate(node))
+            {
+                target.FillRectangle(Brushes.Red, new Rect(0, 0, 100, 100));
+            }
+
+            Assert.Equal(1, node.DrawOperations.Count);
+            Assert.Same(operation, node.DrawOperations.Single());
+
+            Assert.IsType<RectangleNode>(node.DrawOperations[0]);
+        }
+
+        [Fact]
+        public void Should_Replace_Different_DrawOperation()
+        {
+            var node = new VisualNode(new TestRoot(), null);
+            var operation = new RectangleNode(Matrix.Identity, Brushes.Red, null, new Rect(0, 0, 100, 100), 0);
+            var layers = new SceneLayers(node.Visual);
+            var target = new DeferredDrawingContextImpl(null, layers);
+
+            node.LayerRoot = node.Visual;
+            node.AddDrawOperation(operation);
+
+            using (target.BeginUpdate(node))
+            {
+                target.FillRectangle(Brushes.Green, new Rect(0, 0, 100, 100));
+            }
+
+            Assert.Equal(1, node.DrawOperations.Count);
+            Assert.NotSame(operation, node.DrawOperations.Single());
+
+            Assert.IsType<RectangleNode>(node.DrawOperations[0]);
+        }
+
+        [Fact]
+        public void Should_Update_DirtyRects()
+        {
+            var node = new VisualNode(new TestRoot(), null);
+            var operation = new RectangleNode(Matrix.Identity, Brushes.Red, null, new Rect(0, 0, 100, 100), 0);
+            var layers = new SceneLayers(node.Visual);
+            var target = new DeferredDrawingContextImpl(null, layers);
+
+            node.LayerRoot = node.Visual;
+
+            using (target.BeginUpdate(node))
+            {
+                target.FillRectangle(Brushes.Green, new Rect(0, 0, 100, 100));
+            }
+
+            Assert.Equal(new Rect(0, 0, 100, 100), layers.Single().Dirty.Single());
+        }
+
+        [Fact]
+        public void Should_Trim_DrawOperations()
+        {
+            var node = new VisualNode(new TestRoot(), null);
+
+            node.LayerRoot = node.Visual;
+            node.AddDrawOperation(new RectangleNode(Matrix.Identity, Brushes.Red, null, new Rect(0, 0, 10, 100), 0));
+            node.AddDrawOperation(new RectangleNode(Matrix.Identity, Brushes.Red, null, new Rect(0, 0, 20, 100), 0));
+            node.AddDrawOperation(new RectangleNode(Matrix.Identity, Brushes.Red, null, new Rect(0, 0, 30, 100), 0));
+            node.AddDrawOperation(new RectangleNode(Matrix.Identity, Brushes.Red, null, new Rect(0, 0, 40, 100), 0));
+
+            var layers = new SceneLayers(node.Visual);
+            var target = new DeferredDrawingContextImpl(null, layers);
+
+            using (target.BeginUpdate(node))
+            {
+                target.FillRectangle(Brushes.Green, new Rect(0, 0, 10, 100));
+                target.FillRectangle(Brushes.Blue, new Rect(0, 0, 20, 100));
+            }
+
+            Assert.Equal(2, node.DrawOperations.Count);
+        }
+    }
+}
diff --git a/tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/SceneBuilderTests.cs b/tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/SceneBuilderTests.cs
new file mode 100644
index 00000000000..c51e8941a93
--- /dev/null
+++ b/tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/SceneBuilderTests.cs
@@ -0,0 +1,636 @@
+using System;
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Media;
+using Avalonia.Rendering.SceneGraph;
+using Avalonia.UnitTests;
+using Avalonia.VisualTree;
+using Xunit;
+using Avalonia.Layout;
+using Moq;
+using Avalonia.Platform;
+
+namespace Avalonia.Visuals.UnitTests.Rendering.SceneGraph
+{
+    public partial class SceneBuilderTests
+    {
+        [Fact]
+        public void Should_Build_Initial_Scene()
+        {
+            using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
+            {
+                Border border;
+                TextBlock textBlock;
+                var tree = new TestRoot
+                {
+                    Child = border = new Border
+                    {
+                        Width = 100,
+                        Height = 100,
+                        Background = Brushes.Red,
+                        Child = textBlock = new TextBlock
+                        {
+                            Text = "Hello World",
+                        }
+                    }
+                };
+
+                tree.Measure(Size.Infinity);
+                tree.Arrange(new Rect(tree.DesiredSize));
+
+                var result = new Scene(tree);
+                var sceneBuilder = new SceneBuilder();
+                sceneBuilder.UpdateAll(result);
+
+                Assert.Same(tree, ((VisualNode)result.Root).LayerRoot);
+                Assert.Equal(1, result.Root.Children.Count);
+
+                var borderNode = (VisualNode)result.Root.Children[0];
+                Assert.Same(borderNode, result.FindNode(border));
+                Assert.Same(border, borderNode.Visual);
+                Assert.Equal(1, borderNode.Children.Count);
+                Assert.Equal(1, borderNode.DrawOperations.Count);
+
+                var backgroundNode = (RectangleNode)borderNode.DrawOperations[0];
+                Assert.Equal(Brushes.Red, backgroundNode.Brush);
+
+                var textBlockNode = (VisualNode)borderNode.Children[0];
+                Assert.Same(textBlockNode, result.FindNode(textBlock));
+                Assert.Same(textBlock, textBlockNode.Visual);
+                Assert.Equal(1, textBlockNode.DrawOperations.Count);
+
+                var textNode = (TextNode)textBlockNode.DrawOperations[0];
+                Assert.NotNull(textNode.Text);
+            }
+        }
+
+        [Fact]
+        public void Should_Respect_Margin_For_ClipBounds()
+        {
+            using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
+            {
+                Canvas canvas;
+                var tree = new TestRoot
+                {
+                    Width = 200,
+                    Height = 300,
+                    Child = new Border
+                    {
+                        Margin = new Thickness(10, 20, 30, 40),
+                        Child = canvas = new Canvas
+                        {
+                            Background = Brushes.AliceBlue,
+                        }
+                    }
+                };
+
+                tree.Measure(Size.Infinity);
+                tree.Arrange(new Rect(tree.DesiredSize));
+
+                var result = new Scene(tree);
+                var sceneBuilder = new SceneBuilder();
+                sceneBuilder.UpdateAll(result);
+
+                var canvasNode = result.FindNode(canvas);
+                Assert.Equal(new Rect(10, 20, 160, 240), canvasNode.ClipBounds);
+
+                // Initial ClipBounds are correct, make sure they're still correct after updating canvas.
+                result = result.Clone();
+                Assert.True(sceneBuilder.Update(result, canvas));
+
+                canvasNode = result.FindNode(canvas);
+                Assert.Equal(new Rect(10, 20, 160, 240), canvasNode.ClipBounds);
+            }
+        }
+
+        [Fact]
+        public void ClipBounds_Should_Be_Intersection_With_Parent_ClipBounds()
+        {
+            using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
+            {
+                Border border;
+                var tree = new TestRoot
+                {
+                    Width = 200,
+                    Height = 300,
+                    Child = new Canvas
+                    {
+                        ClipToBounds = true,
+                        Width = 100,
+                        Height = 100,
+                        HorizontalAlignment = HorizontalAlignment.Left,
+                        VerticalAlignment = VerticalAlignment.Top,
+                        Children =
+                        {
+                            (border = new Border
+                            {
+                                Background = Brushes.AliceBlue,
+                                Width = 100,
+                                Height = 100,
+                                [Canvas.LeftProperty] = 50,
+                                [Canvas.TopProperty] = 50,
+                            })
+                        }
+                    }
+                };
+
+                tree.Measure(Size.Infinity);
+                tree.Arrange(new Rect(tree.DesiredSize));
+
+                var scene = new Scene(tree);
+                var sceneBuilder = new SceneBuilder();
+                sceneBuilder.UpdateAll(scene);
+
+                var borderNode = scene.FindNode(border);
+                Assert.Equal(new Rect(50, 50, 50, 50), borderNode.ClipBounds);
+
+                // Initial ClipBounds are correct, make sure they're still correct after updating border.
+                scene = scene.Clone();
+                Assert.True(sceneBuilder.Update(scene, border));
+
+                borderNode = scene.FindNode(border);
+                Assert.Equal(new Rect(50, 50, 50, 50), borderNode.ClipBounds);
+            }
+        }
+
+        [Fact]
+        public void Should_Respect_ZIndex()
+        {
+            using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
+            {
+                Border front;
+                Border back;
+                var tree = new TestRoot
+                {
+                    Child = new Panel
+                    {
+                        Children =
+                        {
+                            (front = new Border
+                            {
+                                ZIndex = 1,
+                            }),
+                            (back = new Border
+                            {
+                                ZIndex = 0,
+                            }),
+                        }
+                    }
+                };
+
+                var result = new Scene(tree);
+                var sceneBuilder = new SceneBuilder();
+                sceneBuilder.UpdateAll(result);
+
+                var panelNode = result.FindNode(tree.Child);
+                var expected = new IVisual[] { back, front };
+                var actual = panelNode.Children.OfType<IVisualNode>().Select(x => x.Visual).ToArray();
+                Assert.Equal(expected, actual);
+            }
+        }
+
+        [Fact]
+        public void ClipBounds_Should_Be_In_Global_Coordinates()
+        {
+            using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
+            {
+                Border target;
+                var tree = new TestRoot
+                {
+                    Child = new Decorator
+                    {
+                        Margin = new Thickness(24, 26),
+                        Child = target = new Border
+                        {
+                            Margin = new Thickness(26, 24),
+                            Width = 100,
+                            Height = 100,
+                        }
+                    }
+                };
+
+                tree.Measure(Size.Infinity);
+                tree.Arrange(new Rect(tree.DesiredSize));
+
+                var result = new Scene(tree);
+                var sceneBuilder = new SceneBuilder();
+                sceneBuilder.UpdateAll(result);
+
+                var targetNode = result.FindNode(target);
+
+                Assert.Equal(new Rect(50, 50, 100, 100), targetNode.ClipBounds);
+            }
+        }
+
+        [Fact]
+        public void Transform_For_Control_With_RenderTransform_Should_Be_Correct_After_Update()
+        {
+            using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
+            {
+                Border border;
+                var tree = new TestRoot
+                {
+                    Width = 400,
+                    Height = 200,
+                    Child = new Decorator
+                    {
+                        Width = 200,
+                        Height = 100,
+                        Child = border = new Border
+                        {
+                            Background = Brushes.Red,
+                            HorizontalAlignment = HorizontalAlignment.Right,
+                            Width = 100,
+                            RenderTransform = new ScaleTransform(0.5, 1),
+                        }
+                    }
+                };
+
+                tree.Measure(Size.Infinity);
+                tree.Arrange(new Rect(tree.DesiredSize));
+
+                var scene = new Scene(tree);
+                var sceneBuilder = new SceneBuilder();
+                sceneBuilder.UpdateAll(scene);
+
+                var expectedTransform = Matrix.CreateScale(0.5, 1) * Matrix.CreateTranslation(225, 50);
+                var borderNode = scene.FindNode(border);
+                Assert.Equal(expectedTransform, borderNode.Transform);
+
+                scene = scene.Clone();
+                Assert.True(sceneBuilder.Update(scene, border));
+
+                borderNode = scene.FindNode(border);
+                Assert.Equal(expectedTransform, borderNode.Transform);
+            }
+        }
+
+        [Fact]
+        public void Should_Update_Border_Background_Node()
+        {
+            using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
+            {
+                Border border;
+                TextBlock textBlock;
+                var tree = new TestRoot
+                {
+                    Child = border = new Border
+                    {
+                        Width = 100,
+                        Height = 100,
+                        Background = Brushes.Red,
+                        Child = textBlock = new TextBlock
+                        {
+                            Foreground = Brushes.Green,
+                            Text = "Hello World",
+                        }
+                    }
+                };
+
+                tree.Measure(Size.Infinity);
+                tree.Arrange(new Rect(tree.DesiredSize));
+
+                var initial = new Scene(tree);
+                var sceneBuilder = new SceneBuilder();
+                sceneBuilder.UpdateAll(initial);
+
+                var initialBackgroundNode = initial.FindNode(border).Children[0];
+                var initialTextNode = initial.FindNode(textBlock).DrawOperations[0];
+
+                Assert.NotNull(initialBackgroundNode);
+                Assert.NotNull(initialTextNode);
+
+                border.Background = Brushes.Green;
+
+                var result = initial.Clone();
+                sceneBuilder.Update(result, border);
+                
+                var borderNode = (VisualNode)result.Root.Children[0];
+                Assert.Same(border, borderNode.Visual);
+
+                var backgroundNode = (RectangleNode)borderNode.DrawOperations[0];
+                Assert.NotSame(initialBackgroundNode, backgroundNode);
+                Assert.Equal(Brushes.Green, backgroundNode.Brush);
+
+                var textBlockNode = (VisualNode)borderNode.Children[0];
+                Assert.Same(textBlock, textBlockNode.Visual);
+
+                var textNode = (TextNode)textBlockNode.DrawOperations[0];
+                Assert.Same(initialTextNode, textNode);
+            }
+        }
+
+        [Fact]
+        public void Should_Update_When_Control_Added()
+        {
+            using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
+            {
+                Border border;
+                var tree = new TestRoot
+                {
+                    Width = 100,
+                    Height = 100,
+                    Child = border = new Border
+                    {
+                        Background = Brushes.Red,
+                    }
+                };
+
+                Canvas canvas;
+                var decorator = new Decorator
+                {
+                    Child = canvas = new Canvas(),
+                };
+
+                tree.Measure(Size.Infinity);
+                tree.Arrange(new Rect(tree.DesiredSize));
+
+                var initial = new Scene(tree);
+                var sceneBuilder = new SceneBuilder();
+                sceneBuilder.UpdateAll(initial);
+
+                border.Child = decorator;
+                var result = initial.Clone();
+
+                Assert.True(sceneBuilder.Update(result, decorator));
+
+                // Updating canvas should result in no-op as it should have been updated along 
+                // with decorator as part of the add opeation.
+                Assert.False(sceneBuilder.Update(result, canvas));
+
+                var borderNode = (VisualNode)result.Root.Children[0];
+                Assert.Equal(1, borderNode.Children.Count);
+                Assert.Equal(1, borderNode.DrawOperations.Count);
+
+                var decoratorNode = (VisualNode)borderNode.Children[0];
+                Assert.Same(decorator, decoratorNode.Visual);
+                Assert.Same(decoratorNode, result.FindNode(decorator));
+
+                var canvasNode = (VisualNode)decoratorNode.Children[0];
+                Assert.Same(canvas, canvasNode.Visual);
+                Assert.Same(canvasNode, result.FindNode(canvas));
+            }
+        }
+
+        [Fact]
+        public void Should_Update_When_Control_Removed()
+        {
+            using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
+            {
+                Border border;
+                Decorator decorator;
+                Canvas canvas;
+                var tree = new TestRoot
+                {
+                    Width = 100,
+                    Height = 100,
+                    Child = border = new Border
+                    {
+                        Background = Brushes.Red,
+                        Child = decorator = new Decorator
+                        {
+                            Child = canvas = new Canvas
+                            {
+                                Background = Brushes.AliceBlue,
+                            }
+                        }
+                    }
+                };
+
+                tree.Measure(Size.Infinity);
+                tree.Arrange(new Rect(tree.DesiredSize));
+
+                var initial = new Scene(tree);
+                var sceneBuilder = new SceneBuilder();
+                sceneBuilder.UpdateAll(initial);
+
+                border.Child = null;
+                var result = initial.Clone();
+
+                Assert.True(sceneBuilder.Update(result, decorator));
+                Assert.False(sceneBuilder.Update(result, canvas));
+
+                var borderNode = (VisualNode)result.Root.Children[0];
+                Assert.Equal(0, borderNode.Children.Count);
+                Assert.Equal(1, borderNode.DrawOperations.Count);
+
+                Assert.Null(result.FindNode(decorator));
+                Assert.Equal(new Rect(0, 0, 100, 100), result.Layers.Single().Dirty.Single());
+            }
+        }
+
+        [Fact]
+        public void Should_Update_When_Control_Made_Invisible()
+        {
+            using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
+            {
+                Decorator decorator;
+                Border border;
+                Canvas canvas;
+                var tree = new TestRoot
+                {
+                    Width = 100,
+                    Height = 100,
+                    Child = decorator = new Decorator
+                    {
+                        Child = border = new Border
+                        {
+                            Background = Brushes.Red,
+                            Child = canvas = new Canvas(),
+                        }
+                    }
+                };
+
+                tree.Measure(Size.Infinity);
+                tree.Arrange(new Rect(tree.DesiredSize));
+
+                var initial = new Scene(tree);
+                var sceneBuilder = new SceneBuilder();
+                sceneBuilder.UpdateAll(initial);
+
+                border.IsVisible = false;
+                var result = initial.Clone();
+
+                Assert.True(sceneBuilder.Update(result, border));
+                Assert.False(sceneBuilder.Update(result, canvas));
+
+                var decoratorNode = (VisualNode)result.Root.Children[0];
+                Assert.Equal(0, decoratorNode.Children.Count);
+
+                Assert.Null(result.FindNode(border));
+                Assert.Null(result.FindNode(canvas));
+                Assert.Equal(new Rect(0, 0, 100, 100), result.Layers.Single().Dirty.Single());
+            }
+        }
+
+        [Fact]
+        public void Should_Update_Descendent_Tranform_When_Margin_Changed()
+        {
+            using (TestApplication())
+            {
+                Decorator decorator;
+                Border border;
+                Canvas canvas;
+                var tree = new TestRoot
+                {
+                    Width = 100,
+                    Height = 100,
+                    Child = decorator = new Decorator
+                    {
+                        Margin = new Thickness(0, 10, 0, 0),
+                        Child = border = new Border
+                        {
+                            Child = canvas = new Canvas(),
+                        }
+                    }
+                };
+
+                var layout = AvaloniaLocator.Current.GetService<ILayoutManager>();
+                layout.ExecuteInitialLayoutPass(tree);
+
+                var scene = new Scene(tree);
+                var sceneBuilder = new SceneBuilder();
+                sceneBuilder.UpdateAll(scene);
+
+                var borderNode = scene.FindNode(border);
+                var canvasNode = scene.FindNode(canvas);
+                Assert.Equal(Matrix.CreateTranslation(0, 10), borderNode.Transform);
+                Assert.Equal(Matrix.CreateTranslation(0, 10), canvasNode.Transform);
+
+                decorator.Margin = new Thickness(0, 20, 0, 0);
+                layout.ExecuteLayoutPass();
+
+                scene = scene.Clone();
+                sceneBuilder.Update(scene, decorator);
+
+                borderNode = scene.FindNode(border);
+                canvasNode = scene.FindNode(canvas);
+                Assert.Equal(Matrix.CreateTranslation(0, 20), borderNode.Transform);
+                Assert.Equal(Matrix.CreateTranslation(0, 20), canvasNode.Transform);
+            }
+        }
+
+        [Fact]
+        public void DirtyRects_Should_Contain_Old_And_New_Bounds_When_Margin_Changed()
+        {
+            using (TestApplication())
+            {
+                Decorator decorator;
+                Border border;
+                Canvas canvas;
+                var tree = new TestRoot
+                {
+                    Width = 100,
+                    Height = 100,
+                    Child = decorator = new Decorator
+                    {
+                        Margin = new Thickness(0, 10, 0, 0),
+                        Child = border = new Border
+                        {
+                            Background = Brushes.Red,
+                            Child = canvas = new Canvas(),
+                        }
+                    }
+                };
+
+                var layout = AvaloniaLocator.Current.GetService<ILayoutManager>();
+                layout.ExecuteInitialLayoutPass(tree);
+
+                var scene = new Scene(tree);
+                var sceneBuilder = new SceneBuilder();
+                sceneBuilder.UpdateAll(scene);
+
+                var borderNode = scene.FindNode(border);
+                var canvasNode = scene.FindNode(canvas);
+                Assert.Equal(Matrix.CreateTranslation(0, 10), borderNode.Transform);
+                Assert.Equal(Matrix.CreateTranslation(0, 10), canvasNode.Transform);
+
+                decorator.Margin = new Thickness(0, 20, 0, 0);
+                layout.ExecuteLayoutPass();
+
+                scene = scene.Clone();
+
+                sceneBuilder.Update(scene, decorator);
+
+                var rects = scene.Layers.Single().Dirty.ToArray();
+                Assert.Equal(new[] { new Rect(0, 10, 100, 90) }, rects);
+            }
+        }
+
+        [Fact]
+        public void Resizing_Scene_Should_Add_DirtyRects()
+        {
+            using (TestApplication())
+            {
+                Decorator decorator;
+                Border border;
+                Canvas canvas;
+                var tree = new TestRoot
+                {
+                    Child = decorator = new Decorator
+                    {
+                        Margin = new Thickness(0, 10, 0, 0),
+                        Child = border = new Border
+                        {
+                            Opacity = 0.5,
+                            Background = Brushes.Red,
+                            Child = canvas = new Canvas(),
+                        }
+                    }
+                };
+
+                var scene = new Scene(tree);
+                var sceneBuilder = new SceneBuilder();
+                sceneBuilder.UpdateAll(scene);
+
+                Assert.Equal(new Size(100, 100), scene.Size);
+
+                tree.ClientSize = new Size(110, 120);
+                scene = scene.Clone();
+                sceneBuilder.Update(scene, tree);
+
+                Assert.Equal(new Size(110, 120), scene.Size);
+
+                var expected = new[]
+                {
+                    new Rect(100, 0, 10, 100),
+                    new Rect(0, 100, 110, 20),
+                };
+
+                Assert.Equal(expected, scene.Layers[tree].Dirty.ToArray());
+                Assert.Equal(expected, scene.Layers[border].Dirty.ToArray());
+            }
+        }
+
+        [Fact]
+        public void Should_Set_GeometryClip()
+        {
+            using (TestApplication())
+            {
+                var clip = StreamGeometry.Parse("M100,0 L0,100 100,100");
+                Decorator decorator;
+                var tree = new TestRoot
+                {
+                    Child = decorator = new Decorator
+                    {
+                        Clip = clip,
+                    }
+                };
+
+                var scene = new Scene(tree);
+                var sceneBuilder = new SceneBuilder();
+                sceneBuilder.UpdateAll(scene);
+
+                var decoratorNode = scene.FindNode(decorator);
+                Assert.Same(clip.PlatformImpl, decoratorNode.GeometryClip);
+            }
+        }
+
+        private IDisposable TestApplication()
+        {
+            return UnitTestApplication.Start(
+                TestServices.MockPlatformRenderInterface.With(
+                    layoutManager: new LayoutManager()));
+        }
+    }
+}
diff --git a/tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/SceneBuilderTests_Layers.cs b/tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/SceneBuilderTests_Layers.cs
new file mode 100644
index 00000000000..13f28018db8
--- /dev/null
+++ b/tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/SceneBuilderTests_Layers.cs
@@ -0,0 +1,304 @@
+using System;
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Media;
+using Avalonia.Rendering.SceneGraph;
+using Avalonia.UnitTests;
+using Avalonia.VisualTree;
+using Xunit;
+using Avalonia.Layout;
+using Avalonia.Rendering;
+
+namespace Avalonia.Visuals.UnitTests.Rendering.SceneGraph
+{
+    public partial class SceneBuilderTests
+    {
+        [Fact]
+        public void Control_With_Transparency_Should_Start_New_Layer()
+        {
+            using (TestApplication())
+            {
+                Decorator decorator;
+                Border border;
+                Canvas canvas;
+                var tree = new TestRoot
+                {
+                    Padding = new Thickness(10),
+                    Width = 100,
+                    Height = 120,
+                    Child = decorator = new Decorator
+                    {
+                        Padding = new Thickness(11),
+                        Child = border = new Border
+                        {
+                            Opacity = 0.5,
+                            Background = Brushes.Red,
+                            Padding = new Thickness(12),
+                            Child = canvas = new Canvas(),
+                        }
+                    }
+                };
+
+                var layout = AvaloniaLocator.Current.GetService<ILayoutManager>();
+                layout.ExecuteInitialLayoutPass(tree);
+
+                var scene = new Scene(tree);
+                var sceneBuilder = new SceneBuilder();
+                sceneBuilder.UpdateAll(scene);
+
+                var rootNode = (VisualNode)scene.Root;
+                var borderNode = (VisualNode)scene.FindNode(border);
+                var canvasNode = (VisualNode)scene.FindNode(canvas);
+
+                Assert.Same(tree, rootNode.LayerRoot);
+                Assert.Same(border, borderNode.LayerRoot);
+                Assert.Same(border, canvasNode.LayerRoot);
+                Assert.Equal(0.5, scene.Layers[border].Opacity);
+
+                Assert.Equal(2, scene.Layers.Count());
+                Assert.Empty(scene.Layers.Select(x => x.LayerRoot).Except(new IVisual[] { tree, border }));
+
+                border.Opacity = 1;
+                scene = scene.Clone();
+
+                sceneBuilder.Update(scene, border);
+
+                rootNode = (VisualNode)scene.Root;
+                borderNode = (VisualNode)scene.FindNode(border);
+                canvasNode = (VisualNode)scene.FindNode(canvas);
+
+                Assert.Same(tree, rootNode.LayerRoot);
+                Assert.Same(tree, borderNode.LayerRoot);
+                Assert.Same(tree, canvasNode.LayerRoot);
+                Assert.Equal(1, scene.Layers.Count());
+
+                var rootDirty = scene.Layers[tree].Dirty;
+
+                Assert.Equal(1, rootDirty.Count());
+                Assert.Equal(new Rect(21, 21, 58, 78), rootDirty.Single());
+            }
+        }
+
+        [Fact]
+        public void Control_With_OpacityMask_Should_Start_New_Layer()
+        {
+            using (TestApplication())
+            {
+                Decorator decorator;
+                Border border;
+                Canvas canvas;
+                var tree = new TestRoot
+                {
+                    Padding = new Thickness(10),
+                    Width = 100,
+                    Height = 120,
+                    Child = decorator = new Decorator
+                    {
+                        Padding = new Thickness(11),
+                        Child = border = new Border
+                        {
+                            OpacityMask = Brushes.Red,
+                            Background = Brushes.Red,
+                            Padding = new Thickness(12),
+                            Child = canvas = new Canvas(),
+                        }
+                    }
+                };
+
+                var layout = AvaloniaLocator.Current.GetService<ILayoutManager>();
+                layout.ExecuteInitialLayoutPass(tree);
+
+                var scene = new Scene(tree);
+                var sceneBuilder = new SceneBuilder();
+                sceneBuilder.UpdateAll(scene);
+
+                var rootNode = (VisualNode)scene.Root;
+                var borderNode = (VisualNode)scene.FindNode(border);
+                var canvasNode = (VisualNode)scene.FindNode(canvas);
+
+                Assert.Same(tree, rootNode.LayerRoot);
+                Assert.Same(border, borderNode.LayerRoot);
+                Assert.Same(border, canvasNode.LayerRoot);
+                Assert.Equal(Brushes.Red, scene.Layers[border].OpacityMask);
+
+                Assert.Equal(2, scene.Layers.Count());
+                Assert.Empty(scene.Layers.Select(x => x.LayerRoot).Except(new IVisual[] { tree, border }));
+
+                border.OpacityMask = null;
+                scene = scene.Clone();
+
+                sceneBuilder.Update(scene, border);
+
+                rootNode = (VisualNode)scene.Root;
+                borderNode = (VisualNode)scene.FindNode(border);
+                canvasNode = (VisualNode)scene.FindNode(canvas);
+
+                Assert.Same(tree, rootNode.LayerRoot);
+                Assert.Same(tree, borderNode.LayerRoot);
+                Assert.Same(tree, canvasNode.LayerRoot);
+                Assert.Equal(1, scene.Layers.Count());
+
+                var rootDirty = scene.Layers[tree].Dirty;
+
+                Assert.Equal(1, rootDirty.Count());
+                Assert.Equal(new Rect(21, 21, 58, 78), rootDirty.Single());
+            }
+        }
+
+        [Fact]
+        public void Removing_Transparent_Control_Should_Remove_Layers()
+        {
+            using (TestApplication())
+            {
+                Decorator decorator;
+                Border border;
+                Canvas canvas;
+                var tree = new TestRoot
+                {
+                    Padding = new Thickness(10),
+                    Width = 100,
+                    Height = 120,
+                    Child = decorator = new Decorator
+                    {
+                        Padding = new Thickness(11),
+                        Child = border = new Border
+                        {
+                            Opacity = 0.5,
+                            Background = Brushes.Red,
+                            Padding = new Thickness(12),
+                            Child = canvas = new Canvas
+                            {
+                                Opacity = 0.75,
+                            },
+                        }
+                    }
+                };
+
+                var layout = AvaloniaLocator.Current.GetService<ILayoutManager>();
+                layout.ExecuteInitialLayoutPass(tree);
+
+                var scene = new Scene(tree);
+                var sceneBuilder = new SceneBuilder();
+                sceneBuilder.UpdateAll(scene);
+
+                Assert.Equal(3, scene.Layers.Count);
+
+                decorator.Child = null;
+                scene = scene.Clone();
+
+                sceneBuilder.Update(scene, border);
+
+                Assert.Equal(1, scene.Layers.Count);
+            }
+        }
+
+        [Fact]
+        public void Hiding_Transparent_Control_Should_Remove_Layers()
+        {
+            using (TestApplication())
+            {
+                Decorator decorator;
+                Border border;
+                Canvas canvas;
+                var tree = new TestRoot
+                {
+                    Padding = new Thickness(10),
+                    Width = 100,
+                    Height = 120,
+                    Child = decorator = new Decorator
+                    {
+                        Padding = new Thickness(11),
+                        Child = border = new Border
+                        {
+                            Opacity = 0.5,
+                            Background = Brushes.Red,
+                            Padding = new Thickness(12),
+                            Child = canvas = new Canvas
+                            {
+                                Opacity = 0.75,
+                            },
+                        }
+                    }
+                };
+
+                var layout = AvaloniaLocator.Current.GetService<ILayoutManager>();
+                layout.ExecuteInitialLayoutPass(tree);
+
+                var scene = new Scene(tree);
+                var sceneBuilder = new SceneBuilder();
+                sceneBuilder.UpdateAll(scene);
+
+                Assert.Equal(3, scene.Layers.Count);
+
+                border.IsVisible = false;
+                scene = scene.Clone();
+
+                sceneBuilder.Update(scene, border);
+
+                Assert.Equal(1, scene.Layers.Count);
+            }
+        }
+
+        [Fact]
+        public void GeometryClip_Should_Affect_Child_Layers()
+        {
+            using (TestApplication())
+            {
+                var clip = StreamGeometry.Parse("M100,0 L0,100 100,100");
+                Decorator decorator;
+                Border border;
+                var tree = new TestRoot
+                {
+                    Child = decorator = new Decorator
+                    {
+                        Clip = clip,
+                        Margin = new Thickness(12, 16),
+                        Child = border = new Border
+                        {
+                            Opacity = 0.5,
+                        }
+                    }
+                };
+
+                var layout = AvaloniaLocator.Current.GetService<ILayoutManager>();
+                layout.ExecuteInitialLayoutPass(tree);
+
+                var scene = new Scene(tree);
+                var sceneBuilder = new SceneBuilder();
+                sceneBuilder.UpdateAll(scene);
+
+                var borderLayer = scene.Layers[border];
+                Assert.Equal(
+                    Matrix.CreateTranslation(12, 16),
+                    ((MockStreamGeometryImpl)borderLayer.GeometryClip).Transform);
+            }
+        }
+
+        [Fact]
+        public void Hiding_Root_Should_Not_Remove_Root_Layer()
+        {
+            using (TestApplication())
+            {
+                Border border;
+                var tree = new TestRoot
+                {
+                    Child = border = new Border()
+                };
+
+                var layout = AvaloniaLocator.Current.GetService<ILayoutManager>();
+                layout.ExecuteInitialLayoutPass(tree);
+
+                var scene = new Scene(tree);
+                var sceneBuilder = new SceneBuilder();
+                sceneBuilder.UpdateAll(scene);
+
+                tree.IsVisible = false;
+
+                scene = scene.Clone();
+                sceneBuilder.Update(scene, tree);
+
+                Assert.Equal(1, scene.Layers.Count);
+            }
+        }
+    }
+}
diff --git a/tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/SceneLayersTests.cs b/tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/SceneLayersTests.cs
new file mode 100644
index 00000000000..fac6e1ceb69
--- /dev/null
+++ b/tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/SceneLayersTests.cs
@@ -0,0 +1,36 @@
+using System;
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Rendering.SceneGraph;
+using Avalonia.UnitTests;
+using Avalonia.VisualTree;
+using Xunit;
+
+namespace Avalonia.Visuals.UnitTests.Rendering.SceneGraph
+{
+    public class SceneLayersTests
+    {
+        [Fact]
+        public void Layers_Should_Be_Ordered()
+        {
+            Border border;
+            Decorator decorator;
+            var root = new TestRoot
+            {
+                Child = border = new Border
+                {
+                    Child = decorator = new Decorator(),
+                }
+            };
+
+            var target = new SceneLayers(root);
+            target.Add(root);
+            target.Add(decorator);
+            target.Add(border);
+
+            var result = target.Select(x => x.LayerRoot).ToArray();
+
+            Assert.Equal(new IVisual[] { root, border, decorator }, result);
+        }
+    }
+}
diff --git a/tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/SceneTests.cs b/tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/SceneTests.cs
new file mode 100644
index 00000000000..9c0adc432d8
--- /dev/null
+++ b/tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/SceneTests.cs
@@ -0,0 +1,34 @@
+using System;
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Rendering.SceneGraph;
+using Avalonia.UnitTests;
+using Xunit;
+
+namespace Avalonia.Visuals.UnitTests.Rendering.SceneGraph
+{
+    public class SceneTests
+    {
+        [Fact]
+        public void Cloning_Scene_Should_Retain_Layers_But_Not_DirtyRects()
+        {
+            Decorator decorator;
+            var tree = new TestRoot
+            {
+                Child = decorator = new Decorator(),
+            };
+
+            var scene = new Scene(tree);
+            scene.Layers.Add(tree);
+            scene.Layers.Add(decorator);
+
+            scene.Layers[tree].Dirty.Add(new Rect(0, 0, 100, 100));
+            scene.Layers[decorator].Dirty.Add(new Rect(0, 0, 50, 100));
+
+            scene = scene.Clone();
+            Assert.Equal(2, scene.Layers.Count());
+            Assert.Empty(scene.Layers[0].Dirty);
+            Assert.Empty(scene.Layers[1].Dirty);
+        }
+    }
+}
diff --git a/tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/VisualNodeTests.cs b/tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/VisualNodeTests.cs
new file mode 100644
index 00000000000..3d2e780e0b1
--- /dev/null
+++ b/tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/VisualNodeTests.cs
@@ -0,0 +1,80 @@
+using System;
+using Avalonia.Rendering.SceneGraph;
+using Avalonia.VisualTree;
+using Moq;
+using Xunit;
+
+namespace Avalonia.Visuals.UnitTests.Rendering.SceneGraph
+{
+    public class VisualNodeTests
+    {
+        [Fact]
+        public void Empty_Children_Collections_Should_Be_Shared()
+        {
+            var node1 = new VisualNode(Mock.Of<IVisual>(), null);
+            var node2 = new VisualNode(Mock.Of<IVisual>(), null);
+
+            Assert.Same(node1.Children, node2.Children);
+        }
+
+        [Fact]
+        public void Adding_Child_Should_Create_Collection()
+        {
+            var node = new VisualNode(Mock.Of<IVisual>(), null);
+            var collection = node.Children;
+
+            node.AddChild(Mock.Of<IVisualNode>());
+
+            Assert.NotSame(collection, node.Children);
+        }
+
+        [Fact]
+        public void Empty_DrawOperations_Collections_Should_Be_Shared()
+        {
+            var node1 = new VisualNode(Mock.Of<IVisual>(), null);
+            var node2 = new VisualNode(Mock.Of<IVisual>(), null);
+
+            Assert.Same(node1.DrawOperations, node2.DrawOperations);
+        }
+
+        [Fact]
+        public void Adding_DrawOperation_Should_Create_Collection()
+        {
+            var node = new VisualNode(Mock.Of<IVisual>(), null);
+            var collection = node.DrawOperations;
+
+            node.AddDrawOperation(Mock.Of<IDrawOperation>());
+
+            Assert.NotSame(collection, node.DrawOperations);
+        }
+
+        [Fact]
+        public void Cloned_Nodes_Should_Share_DrawOperations_Collection()
+        {
+            var node1 = new VisualNode(Mock.Of<IVisual>(), null);
+            node1.AddDrawOperation(Mock.Of<IDrawOperation>());
+
+            var node2 = node1.Clone(null);
+
+            Assert.Same(node1.DrawOperations, node2.DrawOperations);
+        }
+
+        [Fact]
+        public void Adding_DrawOperation_To_Cloned_Node_Should_Create_New_Collection()
+        {
+            var node1 = new VisualNode(Mock.Of<IVisual>(), null);
+            var operation1 = Mock.Of<IDrawOperation>();
+            node1.AddDrawOperation(operation1);
+
+            var node2 = node1.Clone(null);
+            var operation2 = Mock.Of<IDrawOperation>();
+            node2.ReplaceDrawOperation(0, operation2);
+
+            Assert.NotSame(node1.DrawOperations, node2.DrawOperations);
+            Assert.Equal(1, node1.DrawOperations.Count);
+            Assert.Equal(1, node2.DrawOperations.Count);
+            Assert.Same(operation1, node1.DrawOperations[0]);
+            Assert.Same(operation2, node2.DrawOperations[0]);
+        }
+    }
+}
diff --git a/tests/Avalonia.Visuals.UnitTests/Rendering/Utilities/TileBrushCalculatorTests.cs b/tests/Avalonia.Visuals.UnitTests/Rendering/Utilities/TileBrushCalculatorTests.cs
new file mode 100644
index 00000000000..8d70b458424
--- /dev/null
+++ b/tests/Avalonia.Visuals.UnitTests/Rendering/Utilities/TileBrushCalculatorTests.cs
@@ -0,0 +1,139 @@
+using System;
+using Avalonia.Controls;
+using Avalonia.Media;
+using Avalonia.Rendering.Utilities;
+using Xunit;
+
+namespace Avalonia.Visuals.UnitTests.Rendering.Utilities
+{
+    public class TileBrushCalculatorTests
+    {
+        [Fact]
+        public void NoTile_Fill_1x()
+        {
+            var result = new TileBrushCalculator(
+                TileMode.None,
+                Stretch.Fill,
+                AlignmentX.Center,
+                AlignmentY.Center,
+                RelativeRect.Fill,
+                RelativeRect.Fill,
+                new Size(100, 100),
+                new Size(100, 100));
+
+            Assert.False(result.NeedsIntermediate);
+            Assert.Equal(new Rect(0, 0, 100, 100), result.SourceRect);
+            Assert.Equal(new Rect(0, 0, 100, 100), result.DestinationRect);
+        }
+
+        [Fact]
+        public void NoTile_Fill_2x()
+        {
+            var result = new TileBrushCalculator(
+                TileMode.None,
+                Stretch.Fill,
+                AlignmentX.Center,
+                AlignmentY.Center,
+                RelativeRect.Fill,
+                RelativeRect.Fill,
+                new Size(100, 100),
+                new Size(200, 200));
+
+            // TODO: This doesn't need an intermediate render target.
+            Assert.True(result.NeedsIntermediate);
+            Assert.Equal(new Rect(0, 0, 100, 100), result.SourceRect);
+            Assert.Equal(new Rect(0, 0, 200, 200), result.DestinationRect);
+        }
+
+        [Fact]
+        public void NoTile_Uniform_CenterHoriz()
+        {
+            var result = new TileBrushCalculator(
+                TileMode.None,
+                Stretch.Uniform,
+                AlignmentX.Center,
+                AlignmentY.Center,
+                RelativeRect.Fill,
+                RelativeRect.Fill,
+                new Size(100, 100),
+                new Size(200, 100));
+
+            Assert.True(result.NeedsIntermediate);
+            Assert.Equal(new Rect(0, 0, 100, 100), result.SourceRect);
+            Assert.Equal(new Rect(0, 0, 200, 100), result.DestinationRect);
+            Assert.Equal(new Size(200, 100), result.IntermediateSize);
+            Assert.Equal(Matrix.CreateTranslation(50, 0), result.IntermediateTransform);
+        }
+
+        [Fact]
+        public void NoTile_Uniform_CenterVert()
+        {
+            var result = new TileBrushCalculator(
+                TileMode.None,
+                Stretch.Uniform,
+                AlignmentX.Center,
+                AlignmentY.Center,
+                RelativeRect.Fill,
+                RelativeRect.Fill,
+                new Size(100, 100),
+                new Size(100, 200));
+
+            Assert.True(result.NeedsIntermediate);
+            Assert.Equal(new Rect(0, 0, 100, 100), result.SourceRect);
+            Assert.Equal(new Rect(0, 0, 100, 200), result.DestinationRect);
+            Assert.Equal(new Size(100, 200), result.IntermediateSize);
+            Assert.Equal(Matrix.CreateTranslation(0, 50), result.IntermediateTransform);
+        }
+
+        [Fact]
+        public void NoTile_NoStretch_BottomRightQuarterDest()
+        {
+            var result = new TileBrushCalculator(
+                TileMode.None,
+                Stretch.None,
+                AlignmentX.Center,
+                AlignmentY.Center,
+                RelativeRect.Fill,
+                new RelativeRect(0.5, 0.5, 0.5, 0.5, RelativeUnit.Relative),
+                new Size(800, 800),
+                new Size(400, 400));
+
+            Assert.True(result.NeedsIntermediate);
+            Assert.Equal(new Rect(0, 0, 800, 800), result.SourceRect);
+            Assert.Equal(new Rect(200, 200, 200, 200), result.DestinationRect);
+            Assert.Equal(new Size(400, 400), result.IntermediateSize);
+            Assert.Equal(new Rect(200, 200, 200, 200), result.IntermediateClip);
+            Assert.Equal(Matrix.CreateTranslation(-100, -100), result.IntermediateTransform);
+        }
+
+        [Fact]
+        public void Tile_NoStretch_BottomRightQuarterSource_CenterQuarterDest()
+        {
+            var result = new TileBrushCalculator(
+                TileMode.Tile,
+                Stretch.None,
+                AlignmentX.Center,
+                AlignmentY.Center,
+                new RelativeRect(0.5, 0.5, 0.5, 0.5, RelativeUnit.Relative),
+                new RelativeRect(0.25, 0.25, 0.5, 0.5, RelativeUnit.Relative),
+                new Size(800, 800),
+                new Size(400, 400));
+
+            var b = new VisualBrush
+            {
+                TileMode = TileMode.Tile,
+                Stretch = Stretch.None,
+                SourceRect = new RelativeRect(0.5, 0.5, 0.5, 0.5, RelativeUnit.Relative),
+                DestinationRect = new RelativeRect(0.25, 0.25, 0.5, 0.5, RelativeUnit.Relative),
+                Visual = new Border { Width = 400, Height = 400 },
+            };
+
+            Assert.True(result.NeedsIntermediate);
+            Assert.Equal(new Rect(400, 400, 400, 400), result.SourceRect);
+            Assert.Equal(new Rect(100, 100, 200, 200), result.DestinationRect);
+            Assert.Equal(new Size(200, 200), result.IntermediateSize);
+            Assert.Equal(new Rect(0, 0, 200, 200), result.IntermediateClip);
+            Assert.Equal(Matrix.CreateTranslation(-500, -500), result.IntermediateTransform);
+        }
+    }
+}
diff --git a/tests/Avalonia.Visuals.UnitTests/VisualTests.cs b/tests/Avalonia.Visuals.UnitTests/VisualTests.cs
index ec5f9a8c13e..f20c59fabeb 100644
--- a/tests/Avalonia.Visuals.UnitTests/VisualTests.cs
+++ b/tests/Avalonia.Visuals.UnitTests/VisualTests.cs
@@ -152,34 +152,32 @@ public void Descendants_Should_RetunVisualRoot()
         public void Attaching_To_Visual_Tree_Should_Invalidate_Visual()
         {
             var renderer = new Mock<IRenderer>();
-
-            using (UnitTestApplication.Start(new TestServices(renderer: (root, loop) => renderer.Object)))
+            var child = new Decorator();
+            var root = new TestRoot
             {
-                var child = new Decorator();
-                var root = new TestRoot();
+                Renderer = renderer.Object,
+            };
 
-                root.Child = child;
+            root.Child = child;
 
-                renderer.Verify(x => x.AddDirty(child));
-            }
+            renderer.Verify(x => x.AddDirty(child));
         }
 
         [Fact]
         public void Detaching_From_Visual_Tree_Should_Invalidate_Visual()
         {
             var renderer = new Mock<IRenderer>();
-
-            using (UnitTestApplication.Start(new TestServices(renderer: (root, loop) => renderer.Object)))
+            var child = new Decorator();
+            var root = new TestRoot
             {
-                var child = new Decorator();
-                var root = new TestRoot();
+                Renderer = renderer.Object,
+            };
 
-                root.Child = child;
-                renderer.ResetCalls();
-                root.Child = null;
+            root.Child = child;
+            renderer.ResetCalls();
+            root.Child = null;
 
-                renderer.Verify(x => x.AddDirty(child));
-            }
+            renderer.Verify(x => x.AddDirty(child));
         }
 
         [Fact]
diff --git a/tests/TestFiles/Cairo/Controls/CustomRender/Clip.expected.png b/tests/TestFiles/Cairo/Controls/CustomRender/Clip.expected.png
new file mode 100644
index 00000000000..c64045d17e8
Binary files /dev/null and b/tests/TestFiles/Cairo/Controls/CustomRender/Clip.expected.png differ
diff --git a/tests/TestFiles/Cairo/Controls/CustomRender/GeometryClip.expected.png b/tests/TestFiles/Cairo/Controls/CustomRender/GeometryClip.expected.png
new file mode 100644
index 00000000000..bb39bf62ca3
Binary files /dev/null and b/tests/TestFiles/Cairo/Controls/CustomRender/GeometryClip.expected.png differ
diff --git a/tests/TestFiles/Cairo/Controls/CustomRender/Opacity.expected.png b/tests/TestFiles/Cairo/Controls/CustomRender/Opacity.expected.png
new file mode 100644
index 00000000000..66d12819f43
Binary files /dev/null and b/tests/TestFiles/Cairo/Controls/CustomRender/Opacity.expected.png differ
diff --git a/tests/TestFiles/Cairo/Controls/CustomRender/OpacityMask.expected.png b/tests/TestFiles/Cairo/Controls/CustomRender/OpacityMask.expected.png
new file mode 100644
index 00000000000..212a4f1eaa6
Binary files /dev/null and b/tests/TestFiles/Cairo/Controls/CustomRender/OpacityMask.expected.png differ
diff --git a/tests/TestFiles/Cairo/GeometryClipping/Geometry_Clip_Clips_Path.expected.png b/tests/TestFiles/Cairo/GeometryClipping/Geometry_Clip_Clips_Path.expected.png
index 892899507b7..1218293ab32 100644
Binary files a/tests/TestFiles/Cairo/GeometryClipping/Geometry_Clip_Clips_Path.expected.png and b/tests/TestFiles/Cairo/GeometryClipping/Geometry_Clip_Clips_Path.expected.png differ
diff --git a/tests/TestFiles/Cairo/Media/RadialGradientBrush/RadialGradientBrush_RedBlue.expected.png b/tests/TestFiles/Cairo/Media/RadialGradientBrush/RadialGradientBrush_RedBlue.expected.png
new file mode 100644
index 00000000000..871a90caf38
Binary files /dev/null and b/tests/TestFiles/Cairo/Media/RadialGradientBrush/RadialGradientBrush_RedBlue.expected.png differ
diff --git a/tests/TestFiles/Direct2D1/Controls/CustomRender/Clip.expected.png b/tests/TestFiles/Direct2D1/Controls/CustomRender/Clip.expected.png
new file mode 100644
index 00000000000..c64045d17e8
Binary files /dev/null and b/tests/TestFiles/Direct2D1/Controls/CustomRender/Clip.expected.png differ
diff --git a/tests/TestFiles/Direct2D1/Controls/CustomRender/GeometryClip.expected.png b/tests/TestFiles/Direct2D1/Controls/CustomRender/GeometryClip.expected.png
new file mode 100644
index 00000000000..bb39bf62ca3
Binary files /dev/null and b/tests/TestFiles/Direct2D1/Controls/CustomRender/GeometryClip.expected.png differ
diff --git a/tests/TestFiles/Direct2D1/Controls/CustomRender/Opacity.expected.png b/tests/TestFiles/Direct2D1/Controls/CustomRender/Opacity.expected.png
new file mode 100644
index 00000000000..66d12819f43
Binary files /dev/null and b/tests/TestFiles/Direct2D1/Controls/CustomRender/Opacity.expected.png differ
diff --git a/tests/TestFiles/Direct2D1/Controls/CustomRender/OpacityMask.expected.png b/tests/TestFiles/Direct2D1/Controls/CustomRender/OpacityMask.expected.png
new file mode 100644
index 00000000000..212a4f1eaa6
Binary files /dev/null and b/tests/TestFiles/Direct2D1/Controls/CustomRender/OpacityMask.expected.png differ
diff --git a/tests/TestFiles/Direct2D1/GeometryClipping/Geometry_Clip_Clips_Path.expected.png b/tests/TestFiles/Direct2D1/GeometryClipping/Geometry_Clip_Clips_Path.expected.png
index 892899507b7..2e5a1ff6a71 100644
Binary files a/tests/TestFiles/Direct2D1/GeometryClipping/Geometry_Clip_Clips_Path.expected.png and b/tests/TestFiles/Direct2D1/GeometryClipping/Geometry_Clip_Clips_Path.expected.png differ
diff --git a/tests/TestFiles/Direct2D1/Media/RadialGradientBrush/RadialGradientBrush_RedBlue.expected.png b/tests/TestFiles/Direct2D1/Media/RadialGradientBrush/RadialGradientBrush_RedBlue.expected.png
new file mode 100644
index 00000000000..fce116d98d2
Binary files /dev/null and b/tests/TestFiles/Direct2D1/Media/RadialGradientBrush/RadialGradientBrush_RedBlue.expected.png differ
diff --git a/tests/TestFiles/Direct2D1/Media/VisualBrush/VisualBrush_InTree_Visual.expected.png b/tests/TestFiles/Direct2D1/Media/VisualBrush/VisualBrush_InTree_Visual.expected.png
new file mode 100644
index 00000000000..3725f2acbc0
Binary files /dev/null and b/tests/TestFiles/Direct2D1/Media/VisualBrush/VisualBrush_InTree_Visual.expected.png differ
diff --git a/tests/TestFiles/Skia/Controls/CustomRender/Clip.expected.png b/tests/TestFiles/Skia/Controls/CustomRender/Clip.expected.png
new file mode 100644
index 00000000000..c64045d17e8
Binary files /dev/null and b/tests/TestFiles/Skia/Controls/CustomRender/Clip.expected.png differ
diff --git a/tests/TestFiles/Skia/Controls/CustomRender/GeometryClip.expected.png b/tests/TestFiles/Skia/Controls/CustomRender/GeometryClip.expected.png
new file mode 100644
index 00000000000..535d411cc7a
Binary files /dev/null and b/tests/TestFiles/Skia/Controls/CustomRender/GeometryClip.expected.png differ
diff --git a/tests/TestFiles/Skia/Controls/CustomRender/Opacity.expected.png b/tests/TestFiles/Skia/Controls/CustomRender/Opacity.expected.png
new file mode 100644
index 00000000000..66d12819f43
Binary files /dev/null and b/tests/TestFiles/Skia/Controls/CustomRender/Opacity.expected.png differ
diff --git a/tests/TestFiles/Skia/Controls/CustomRender/OpacityMask.expected.png b/tests/TestFiles/Skia/Controls/CustomRender/OpacityMask.expected.png
new file mode 100644
index 00000000000..212a4f1eaa6
Binary files /dev/null and b/tests/TestFiles/Skia/Controls/CustomRender/OpacityMask.expected.png differ
diff --git a/tests/TestFiles/Skia/GeometryClipping/Geometry_Clip_Clips_Path.expected.png b/tests/TestFiles/Skia/GeometryClipping/Geometry_Clip_Clips_Path.expected.png
index 892899507b7..5993088a33d 100644
Binary files a/tests/TestFiles/Skia/GeometryClipping/Geometry_Clip_Clips_Path.expected.png and b/tests/TestFiles/Skia/GeometryClipping/Geometry_Clip_Clips_Path.expected.png differ