diff --git a/native/Avalonia.Native/inc/avalonia-native.h b/native/Avalonia.Native/inc/avalonia-native.h
index 0c965b7498..4b814a9cfb 100644
--- a/native/Avalonia.Native/inc/avalonia-native.h
+++ b/native/Avalonia.Native/inc/avalonia-native.h
@@ -173,6 +173,12 @@ public:
     virtual HRESULT ObtainGlFeature(IAvnGlFeature** ppv) = 0;
 };
 
+AVNCOM(IAvnString, 17) : IUnknown
+{
+    virtual HRESULT Pointer(void**retOut) = 0;
+    virtual HRESULT Length(int*ret) = 0;
+};
+
 AVNCOM(IAvnWindowBase, 02) : IUnknown
 {
     virtual HRESULT Show() = 0;
@@ -207,10 +213,10 @@ AVNCOM(IAvnPopup, 03) : virtual IAvnWindowBase
 
 AVNCOM(IAvnWindow, 04) : virtual IAvnWindowBase
 {
-    virtual HRESULT ShowDialog (IUnknown**ppv) = 0;
+    virtual HRESULT ShowDialog (IAvnWindow* parent) = 0;
     virtual HRESULT SetCanResize(bool value) = 0;
     virtual HRESULT SetHasDecorations(bool value) = 0;
-    virtual HRESULT SetTitle (const char* title) = 0;
+    virtual HRESULT SetTitle (void* utf8Title) = 0;
     virtual HRESULT SetTitleBarColor (AvnColor color) = 0;
     virtual HRESULT SetWindowState(AvnWindowState state) = 0;
     virtual HRESULT GetWindowState(AvnWindowState*ret) = 0;
@@ -315,8 +321,8 @@ AVNCOM(IAvnScreens, 0e) : IUnknown
 
 AVNCOM(IAvnClipboard, 0f) : IUnknown
 {
-    virtual HRESULT GetText (void** retOut) = 0;
-    virtual HRESULT SetText (char* text) = 0;
+    virtual HRESULT GetText (IAvnString**ppv) = 0;
+    virtual HRESULT SetText (void* utf8Text) = 0;
     virtual HRESULT Clear() = 0;
 };
 
diff --git a/native/Avalonia.Native/src/OSX/Avalonia.Native.OSX.xcodeproj/project.pbxproj b/native/Avalonia.Native/src/OSX/Avalonia.Native.OSX.xcodeproj/project.pbxproj
index bd8ac481a8..cc74d5669f 100644
--- a/native/Avalonia.Native/src/OSX/Avalonia.Native.OSX.xcodeproj/project.pbxproj
+++ b/native/Avalonia.Native/src/OSX/Avalonia.Native.OSX.xcodeproj/project.pbxproj
@@ -9,6 +9,7 @@
 /* Begin PBXBuildFile section */
 		37A517B32159597E00FBA241 /* Screens.mm in Sources */ = {isa = PBXBuildFile; fileRef = 37A517B22159597E00FBA241 /* Screens.mm */; };
 		37C09D8821580FE4006A6758 /* SystemDialogs.mm in Sources */ = {isa = PBXBuildFile; fileRef = 37C09D8721580FE4006A6758 /* SystemDialogs.mm */; };
+		37DDA9B0219330F8002E132B /* AvnString.mm in Sources */ = {isa = PBXBuildFile; fileRef = 37DDA9AF219330F8002E132B /* AvnString.mm */; };
 		37E2330F21583241000CB7E2 /* KeyTransform.mm in Sources */ = {isa = PBXBuildFile; fileRef = 37E2330E21583241000CB7E2 /* KeyTransform.mm */; };
 		5B21A982216530F500CEE36E /* cursor.mm in Sources */ = {isa = PBXBuildFile; fileRef = 5B21A981216530F500CEE36E /* cursor.mm */; };
 		5B8BD94F215BFEA6005ED2A7 /* clipboard.mm in Sources */ = {isa = PBXBuildFile; fileRef = 5B8BD94E215BFEA6005ED2A7 /* clipboard.mm */; };
@@ -26,6 +27,8 @@
 		37A517B22159597E00FBA241 /* Screens.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = Screens.mm; sourceTree = "<group>"; };
 		37C09D8721580FE4006A6758 /* SystemDialogs.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = SystemDialogs.mm; sourceTree = "<group>"; };
 		37C09D8A21581EF2006A6758 /* window.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = window.h; sourceTree = "<group>"; };
+		37DDA9AF219330F8002E132B /* AvnString.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = AvnString.mm; sourceTree = "<group>"; };
+		37DDA9B121933371002E132B /* AvnString.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AvnString.h; sourceTree = "<group>"; };
 		37E2330E21583241000CB7E2 /* KeyTransform.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = KeyTransform.mm; sourceTree = "<group>"; };
 		5B21A981216530F500CEE36E /* cursor.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = cursor.mm; sourceTree = "<group>"; };
 		5B8BD94E215BFEA6005ED2A7 /* clipboard.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = clipboard.mm; sourceTree = "<group>"; };
@@ -65,6 +68,8 @@
 		AB7A61E62147C814003C5833 = {
 			isa = PBXGroup;
 			children = (
+				37DDA9B121933371002E132B /* AvnString.h */,
+				37DDA9AF219330F8002E132B /* AvnString.mm */,
 				37A4E71A2178846A00EACBCD /* headers */,
 				AB573DC3217605E400D389A2 /* gl.mm */,
 				5BF943652167AD1D009CAE35 /* cursor.h */,
@@ -161,6 +166,7 @@
 			files = (
 				5B8BD94F215BFEA6005ED2A7 /* clipboard.mm in Sources */,
 				5B21A982216530F500CEE36E /* cursor.mm in Sources */,
+				37DDA9B0219330F8002E132B /* AvnString.mm in Sources */,
 				AB8F7D6B21482D7F0057DBA5 /* platformthreading.mm in Sources */,
 				37E2330F21583241000CB7E2 /* KeyTransform.mm in Sources */,
 				37A517B32159597E00FBA241 /* Screens.mm in Sources */,
diff --git a/native/Avalonia.Native/src/OSX/AvnString.h b/native/Avalonia.Native/src/OSX/AvnString.h
new file mode 100644
index 0000000000..9a8f5a1318
--- /dev/null
+++ b/native/Avalonia.Native/src/OSX/AvnString.h
@@ -0,0 +1,14 @@
+//
+//  AvnString.h
+//  Avalonia.Native.OSX
+//
+//  Created by Dan Walmsley on 07/11/2018.
+//  Copyright © 2018 Avalonia. All rights reserved.
+//
+
+#ifndef AvnString_h
+#define AvnString_h
+
+extern IAvnString* CreateAvnString(NSString* string);
+
+#endif /* AvnString_h */
diff --git a/native/Avalonia.Native/src/OSX/AvnString.mm b/native/Avalonia.Native/src/OSX/AvnString.mm
new file mode 100644
index 0000000000..b491cf2a92
--- /dev/null
+++ b/native/Avalonia.Native/src/OSX/AvnString.mm
@@ -0,0 +1,55 @@
+//
+//  AvnString.m
+//  Avalonia.Native.OSX
+//
+//  Created by Dan Walmsley on 07/11/2018.
+//  Copyright © 2018 Avalonia. All rights reserved.
+//
+
+#include "common.h"
+
+class AvnStringImpl : public virtual ComSingleObject<IAvnString, &IID_IAvnString>
+{
+private:
+    NSString* _string;
+    
+public:
+    FORWARD_IUNKNOWN()
+    
+    AvnStringImpl(NSString* string)
+    {
+        _string = string;
+    }
+    
+    virtual HRESULT Pointer(void**retOut) override
+    {
+        @autoreleasepool
+        {
+            if(retOut == nullptr)
+            {
+                return E_POINTER;
+            }
+            
+            *retOut = (void*)_string.UTF8String;
+            
+            return S_OK;
+        }
+    }
+    
+    virtual HRESULT Length(int*retOut) override
+    {
+        if(retOut == nullptr)
+        {
+            return E_POINTER;
+        }
+        
+        *retOut = (int)_string.length;
+        
+        return S_OK;
+    }
+};
+
+IAvnString* CreateAvnString(NSString* string)
+{
+    return new AvnStringImpl(string);
+}
diff --git a/native/Avalonia.Native/src/OSX/clipboard.mm b/native/Avalonia.Native/src/OSX/clipboard.mm
index 19e5c25801..53c1fe3c2c 100644
--- a/native/Avalonia.Native/src/OSX/clipboard.mm
+++ b/native/Avalonia.Native/src/OSX/clipboard.mm
@@ -2,29 +2,34 @@
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
 #include "common.h"
+#include "AvnString.h"
 
 class Clipboard : public ComSingleObject<IAvnClipboard, &IID_IAvnClipboard>
 {
 public:
     FORWARD_IUNKNOWN()
-    virtual HRESULT GetText (void** retOut) override
+    virtual HRESULT GetText (IAvnString**ppv) override
     {
         @autoreleasepool
         {
-            NSString *str = [[NSPasteboard generalPasteboard] stringForType:NSPasteboardTypeString];
-            *retOut = (void *)str.UTF8String;
+            if(ppv == nullptr)
+            {
+                return E_POINTER;
+            }
+            
+            *ppv = CreateAvnString([[NSPasteboard generalPasteboard] stringForType:NSPasteboardTypeString]);
+            
+            return S_OK;
         }
-        
-        return S_OK;
     }
     
-    virtual HRESULT SetText (char* text) override
+    virtual HRESULT SetText (void* utf8String) override
     {
         @autoreleasepool
         {
             NSPasteboard *pasteBoard = [NSPasteboard generalPasteboard];
             [pasteBoard clearContents];
-            [pasteBoard setString:@(text) forType:NSPasteboardTypeString];
+            [pasteBoard setString:[NSString stringWithUTF8String:(const char*)utf8String] forType:NSPasteboardTypeString];
         }
         
         return S_OK;
diff --git a/native/Avalonia.Native/src/OSX/common.h b/native/Avalonia.Native/src/OSX/common.h
index 1647569269..f748dd59ad 100644
--- a/native/Avalonia.Native/src/OSX/common.h
+++ b/native/Avalonia.Native/src/OSX/common.h
@@ -31,4 +31,13 @@ extern NSSize ToNSSize (AvnSize s);
 #define NSDebugLog(...) (void)0
 #endif
 
+template<typename T> inline T* objc_cast(id from) {
+    if(from == nil)
+        return nil;
+    if ([from isKindOfClass:[T class]]) {
+        return static_cast<T*>(from);
+    }
+    return nil;
+}
+
 #endif
diff --git a/native/Avalonia.Native/src/OSX/main.mm b/native/Avalonia.Native/src/OSX/main.mm
index 4d6dcfed85..5043246c53 100644
--- a/native/Avalonia.Native/src/OSX/main.mm
+++ b/native/Avalonia.Native/src/OSX/main.mm
@@ -32,27 +32,23 @@ public:
 - (void) do;
 @end
 @implementation ThreadingInitializer
-
-pthread_mutex_t mutex;
-pthread_cond_t cond;
-
+{
+    int _fds[2];
+}
 - (void) runOnce
 {
-    pthread_mutex_lock(&mutex);
-    pthread_cond_signal(&cond);
-    pthread_mutex_unlock(&mutex);
+    char buf[]={0};
+    write(_fds[1], buf, 1);
 }
 
 - (void) do
 {
-    pthread_mutex_init(&mutex, NULL);
-    pthread_cond_init(&cond, NULL);
+    pipe(_fds);
     [[[NSThread alloc] initWithTarget:self selector:@selector(runOnce) object:nil] start];
-    pthread_mutex_lock(&mutex);
-    pthread_cond_wait(&cond, &mutex);
-    pthread_mutex_unlock(&mutex);
-    pthread_cond_destroy(&cond);
-    pthread_mutex_destroy(&mutex);
+    char buf[1];
+    read(_fds[0], buf, 1);
+    close(_fds[0]);
+    close(_fds[1]);
 }
 
 
diff --git a/native/Avalonia.Native/src/OSX/window.h b/native/Avalonia.Native/src/OSX/window.h
index 34592993c3..e2221217f3 100644
--- a/native/Avalonia.Native/src/OSX/window.h
+++ b/native/Avalonia.Native/src/OSX/window.h
@@ -18,6 +18,8 @@ class WindowBaseImpl;
 -(AvnWindow* _Nonnull) initWithParent: (WindowBaseImpl* _Nonnull) parent;
 -(void) setCanBecomeKeyAndMain;
 -(void) pollModalSession: (NSModalSession _Nonnull) session;
+-(void) restoreParentWindow;
+-(bool) shouldTryToHandleEvents;
 @end
 
 struct INSWindowHolder
diff --git a/native/Avalonia.Native/src/OSX/window.mm b/native/Avalonia.Native/src/OSX/window.mm
index 362b765b3d..ae00bde780 100644
--- a/native/Avalonia.Native/src/OSX/window.mm
+++ b/native/Avalonia.Native/src/OSX/window.mm
@@ -109,6 +109,7 @@ public:
             if(Window != nullptr)
             {
                 [Window orderOut:Window];
+                [Window restoreParentWindow];
             }
             
             return S_OK;
@@ -392,30 +393,6 @@ protected:
     }
 };
 
-class ModalDisposable : public ComUnknownObject
-{
-    NSModalSession _session;
-    AvnWindow* _window;
-    
-    void Dispose ()
-    {
-        [_window orderOut:_window];
-        [NSApp endModalSession:_session];
-    }
-    
-public:
-    ModalDisposable(AvnWindow* window, NSModalSession session)
-    {
-        _session = session;
-        _window = window;
-    }
-    
-    virtual ~ModalDisposable()
-    {
-        Dispose();
-    }
-};
-
 class WindowImpl : public virtual WindowBaseImpl, public virtual IAvnWindow, public IWindowStateChanged
 {
 private:
@@ -444,32 +421,27 @@ private:
     {
         @autoreleasepool
         {
+            if([Window parentWindow] != nil)
+                [[Window parentWindow] removeChildWindow:Window];
             WindowBaseImpl::Show();
             
             return SetWindowState(_lastWindowState);
         }
     }
     
-    virtual HRESULT ShowDialog (IUnknown**ppv) override
+    virtual HRESULT ShowDialog (IAvnWindow* parent) override
     {
         @autoreleasepool
         {
-            if(ppv == nullptr)
-            {
+            if(parent == nullptr)
                 return E_POINTER;
-            }
-            
-            auto session = [NSApp beginModalSessionForWindow:Window];
-            auto disposable = new ModalDisposable(Window, session);
-            *ppv = disposable;
-            
-            SetPosition(lastPositionSet);
-            UpdateStyle();
-            
-            [Window setTitle:_lastTitle];
-            [Window setTitleVisibility:NSWindowTitleVisible];
+
+            auto cparent = dynamic_cast<WindowImpl*>(parent);
+            if(cparent == nullptr)
+                return E_INVALIDARG;
             
-            [Window pollModalSession:session];
+            [cparent->Window addChildWindow:Window ordered:NSWindowAbove];
+            WindowBaseImpl::Show();
             
             return S_OK;
         }
@@ -530,11 +502,11 @@ private:
         }
     }
     
-    virtual HRESULT SetTitle (const char* title) override
+    virtual HRESULT SetTitle (void* utf8title) override
     {
         @autoreleasepool
         {
-            _lastTitle = [NSString stringWithUTF8String:title];
+            _lastTitle = [NSString stringWithUTF8String:(const char*)utf8title];
             [Window setTitle:_lastTitle];
             [Window setTitleVisibility:NSWindowTitleVisible];
             
@@ -843,8 +815,19 @@ NSArray* AllLoopModes = [NSArray arrayWithObjects: NSDefaultRunLoopMode, NSEvent
     [super viewDidChangeBackingProperties];
 }
 
+- (bool) ignoreUserInput
+{
+    auto parentWindow = objc_cast<AvnWindow>([self window]);
+    if(parentWindow == nil || ![parentWindow shouldTryToHandleEvents])
+        return TRUE;
+    return FALSE;
+}
+
 - (void)mouseEvent:(NSEvent *)event withType:(AvnRawMouseEventType) type
 {
+    if([self ignoreUserInput])
+        return;
+    
     [self becomeFirstResponder];
     auto localPoint = [self convertPoint:[event locationInWindow] toView:self];
     auto avnPoint = [self toAvnPoint:localPoint];
@@ -952,7 +935,9 @@ NSArray* AllLoopModes = [NSArray arrayWithObjects: NSDefaultRunLoopMode, NSEvent
 } 
 
 - (void) keyboardEvent: (NSEvent *) event withType: (AvnRawKeyEventType)type
-{ 
+{
+    if([self ignoreUserInput])
+        return;
     auto key = s_KeyMap[[event keyCode]];
     
     auto timestamp = [event timestamp] * 1000;
@@ -1125,13 +1110,15 @@ NSArray* AllLoopModes = [NSArray arrayWithObjects: NSDefaultRunLoopMode, NSEvent
     {
         ComPtr<WindowBaseImpl> parent = _parent;
         _parent = NULL;
+        [self restoreParentWindow];
         parent->BaseEvents->Closed();
         [parent->View onClosed];
-        [self setContentView: nil];
+        dispatch_async(dispatch_get_main_queue(), ^{
+            [self setContentView: nil];
+        });
     }
 }
 
-
 -(BOOL)canBecomeKeyWindow
 {
     return _canBecomeKeyAndMain;
@@ -1142,12 +1129,62 @@ NSArray* AllLoopModes = [NSArray arrayWithObjects: NSDefaultRunLoopMode, NSEvent
     return _canBecomeKeyAndMain;
 }
 
+-(bool) activateAppropriateChild: (bool)activating
+{
+    for(NSWindow* uch in [self childWindows])
+    {
+        auto ch = objc_cast<AvnWindow>(uch);
+        if(ch == nil)
+            continue;
+        [ch activateAppropriateChild:false];
+        return FALSE;
+    }
+    
+    if(!activating)
+        [self makeKeyAndOrderFront:self];
+    return TRUE;
+}
+
+-(bool)shouldTryToHandleEvents
+{
+    for(NSWindow* uch in [self childWindows])
+    {
+        auto ch = objc_cast<AvnWindow>(uch);
+        if(ch == nil)
+            continue;
+        return FALSE;
+    }
+    return TRUE;
+}
+
+-(void)makeKeyWindow
+{
+    if([self activateAppropriateChild: true])
+    {
+        [super makeKeyWindow];
+    }
+}
+
 -(void)becomeKeyWindow
 {
-    _parent->BaseEvents->Activated();
-    [super becomeKeyWindow];
+    if([self activateAppropriateChild: true])
+    {
+        _parent->BaseEvents->Activated();
+        [super becomeKeyWindow];
+    }
+}
+
+-(void) restoreParentWindow;
+{
+    auto parent = objc_cast<AvnWindow>([self parentWindow]);
+    if(parent != nil)
+    {
+        [parent removeChildWindow:self];
+        [parent activateAppropriateChild: false];
+    }
 }
 
+
 - (BOOL)windowShouldZoom:(NSWindow *)window toFrame:(NSRect)newFrame
 {
     return true;
diff --git a/samples/ControlCatalog.Desktop/Program.cs b/samples/ControlCatalog.Desktop/Program.cs
index a2048005a4..329b2ab5a3 100644
--- a/samples/ControlCatalog.Desktop/Program.cs
+++ b/samples/ControlCatalog.Desktop/Program.cs
@@ -22,7 +22,7 @@ namespace ControlCatalog
         /// This method is needed for IDE previewer infrastructure
         /// </summary>
         public static AppBuilder BuildAvaloniaApp()
-            => AppBuilder.Configure<App>().LogToDebug().UsePlatformDetect();
+            => AppBuilder.Configure<App>().LogToDebug().UsePlatformDetect().UseReactiveUI();
 
         private static void ConfigureAssetAssembly(AppBuilder builder)
         {
diff --git a/samples/ControlCatalog/Pages/DialogsPage.xaml b/samples/ControlCatalog/Pages/DialogsPage.xaml
index 710d791f3a..353edce51c 100644
--- a/samples/ControlCatalog/Pages/DialogsPage.xaml
+++ b/samples/ControlCatalog/Pages/DialogsPage.xaml
@@ -3,10 +3,7 @@
       <Button Name="OpenFile">Open File</Button>
       <Button Name="SaveFile">Save File</Button>
       <Button Name="SelectFolder">Select Folder</Button>
-      <StackPanel Orientation="Horizontal">
-          <CheckBox Name="IsModal" IsChecked="True"/>
-          <TextBlock>Modal to window</TextBlock>
-      </StackPanel>
       <Button Name="DecoratedWindow">Decorated window</Button>
+      <Button Name="Dialog">Dialog</Button>
   </StackPanel>
 </UserControl>
diff --git a/samples/ControlCatalog/Pages/DialogsPage.xaml.cs b/samples/ControlCatalog/Pages/DialogsPage.xaml.cs
index 8b3e810f0a..e380c677c9 100644
--- a/samples/ControlCatalog/Pages/DialogsPage.xaml.cs
+++ b/samples/ControlCatalog/Pages/DialogsPage.xaml.cs
@@ -31,12 +31,18 @@ namespace ControlCatalog.Pages
                 }.ShowAsync(GetWindow());
             };
             this.FindControl<Button>("DecoratedWindow").Click += delegate
-            {
-                new DecoratedWindow().Show();
-            };
+                {
+                    new DecoratedWindow().ShowDialog(GetWindow());
+                };
+            this.FindControl<Button>("Dialog").Click += delegate
+                {
+                    new MainWindow().ShowDialog(GetWindow());
+                };
+
+
         }
 
-        Window GetWindow() => this.FindControl<CheckBox>("IsModal").IsChecked.Value ? (Window)this.VisualRoot : null;
+        Window GetWindow() => (Window)this.VisualRoot;
 
         private void InitializeComponent()
         {
diff --git a/samples/ControlCatalog/Pages/MenuPage.xaml.cs b/samples/ControlCatalog/Pages/MenuPage.xaml.cs
index ec7c000fe6..5a07cae89f 100644
--- a/samples/ControlCatalog/Pages/MenuPage.xaml.cs
+++ b/samples/ControlCatalog/Pages/MenuPage.xaml.cs
@@ -83,7 +83,7 @@ namespace ControlCatalog.Pages
         public async Task Open()
         {
             var dialog = new OpenFileDialog();
-            var result = await dialog.ShowAsync();
+            var result = await dialog.ShowAsync(App.Current.MainWindow);
 
             if (result != null)
             {
diff --git a/samples/ControlCatalog/Pages/NumericUpDownPage.xaml b/samples/ControlCatalog/Pages/NumericUpDownPage.xaml
index 2bb6214b58..e263f59b8d 100644
--- a/samples/ControlCatalog/Pages/NumericUpDownPage.xaml
+++ b/samples/ControlCatalog/Pages/NumericUpDownPage.xaml
@@ -6,7 +6,7 @@
 
     <TextBlock Margin="2,5,2,2" FontSize="14" FontWeight="Bold">Features:</TextBlock>
     <Grid Margin="2" ColumnDefinitions="Auto,Auto,Auto,Auto" RowDefinitions="Auto,Auto">
-      <Grid Grid.Row="0" Grid.Column="0" ColumnDefinitions="Auto, Auto" RowDefinitions="35,35,35,35,35">
+      <Grid Grid.Row="0" Grid.Column="0" ColumnDefinitions="Auto, Auto" RowDefinitions="Auto,Auto,Auto,Auto,Auto">
         <TextBlock Grid.Row="0" Grid.Column="0" VerticalAlignment="Center" Margin="2">ShowButtonSpinner:</TextBlock>
         <CheckBox Grid.Row="0" Grid.Column="1" IsChecked="{Binding #upDown.ShowButtonSpinner}" VerticalAlignment="Center" Margin="2"/>
 
@@ -20,7 +20,7 @@
         <CheckBox Grid.Row="3" Grid.Column="1" IsChecked="{Binding #upDown.ClipValueToMinMax}" VerticalAlignment="Center" Margin="2"/>
 
       </Grid>
-      <Grid Grid.Row="0" Grid.Column="1" Margin="10,2,2,2" ColumnDefinitions="Auto, 120" RowDefinitions="35,35,35,35,35">
+      <Grid Grid.Row="0" Grid.Column="1" Margin="10,2,2,2" ColumnDefinitions="Auto, 120" RowDefinitions="Auto,Auto,Auto,Auto,Auto">
         <TextBlock Grid.Row="0" Grid.Column="0" VerticalAlignment="Center" Margin="2">FormatString:</TextBlock>
         <DropDown Grid.Row="0" Grid.Column="1" Items="{Binding Formats}" SelectedItem="{Binding SelectedFormat}"
                   VerticalAlignment="Center" Margin="2">
@@ -49,22 +49,22 @@
         <TextBlock Grid.Row="4" Grid.Column="0" VerticalAlignment="Center" Margin="2">Text:</TextBlock>
         <TextBox Grid.Row="4" Grid.Column="1" Text="{Binding #upDown.Text}" VerticalAlignment="Center" Margin="2" />
       </Grid>
-      <Grid Grid.Row="0" Grid.Column="2" Margin="10,2,2,2" RowDefinitions="35,35,35,35,35" ColumnDefinitions="Auto, 120">
+      <Grid Grid.Row="0" Grid.Column="2" Margin="10,2,2,2" RowDefinitions="Auto,Auto,Auto,Auto,Auto" ColumnDefinitions="Auto, 120">
         <TextBlock Grid.Row="0" Grid.Column="0" VerticalAlignment="Center" Margin="10,2,2,2">Minimum:</TextBlock>
         <NumericUpDown Grid.Row="0" Grid.Column="1" Value="{Binding #upDown.Minimum}"
-                       CultureInfo="{Binding #upDown.CultureInfo}" VerticalAlignment="Center" Height="25" Margin="2" Width="70" HorizontalAlignment="Center"/>
+                       CultureInfo="{Binding #upDown.CultureInfo}" VerticalAlignment="Center" Margin="2" Width="70" HorizontalAlignment="Center"/>
 
         <TextBlock Grid.Row="1" Grid.Column="0" VerticalAlignment="Center" Margin="10,2,2,2">Maximum:</TextBlock>
         <NumericUpDown Grid.Row="1" Grid.Column="1" Value="{Binding #upDown.Maximum}"
-                       CultureInfo="{Binding #upDown.CultureInfo}" VerticalAlignment="Center" Height="25" Margin="2" Width="70" HorizontalAlignment="Center"/>
+                       CultureInfo="{Binding #upDown.CultureInfo}" VerticalAlignment="Center" Margin="2" Width="70" HorizontalAlignment="Center"/>
 
         <TextBlock Grid.Row="2" Grid.Column="0" VerticalAlignment="Center" Margin="10,2,2,2">Increment:</TextBlock>
         <NumericUpDown Grid.Row="2" Grid.Column="1" Value="{Binding #upDown.Increment}" VerticalAlignment="Center"
-                       Height="25" Margin="2" Width="70" HorizontalAlignment="Center"/>
+                       Margin="2" Width="70" HorizontalAlignment="Center"/>
 
         <TextBlock Grid.Row="3" Grid.Column="0" VerticalAlignment="Center" Margin="10,2,2,2">Value:</TextBlock>
         <NumericUpDown Grid.Row="3" Grid.Column="1" Value="{Binding #upDown.Value}" VerticalAlignment="Center"
-                       Height="25" Margin="2" Width="70" HorizontalAlignment="Center"/>
+                       Margin="2" Width="70" HorizontalAlignment="Center"/>
 
       </Grid>
     </Grid>
@@ -72,7 +72,7 @@
     <StackPanel Margin="2,10,2,2" Orientation="Horizontal" Spacing="10">
       <TextBlock FontSize="14" FontWeight="Bold" VerticalAlignment="Center">Usage of NumericUpDown:</TextBlock>
       <NumericUpDown Name="upDown" Minimum="0" Maximum="10" Increment="0.5"
-                     CultureInfo="en-US" VerticalAlignment="Center" Height="25" Width="100"
+                     CultureInfo="en-US" VerticalAlignment="Center" Width="100"
                      Watermark="Enter text" FormatString="{Binding SelectedFormat.Value}"/>
     </StackPanel>
 
diff --git a/scripts/ReplaceNugetCache.sh b/scripts/ReplaceNugetCache.sh
index d50f4152e8..4cc11edd60 100755
--- a/scripts/ReplaceNugetCache.sh
+++ b/scripts/ReplaceNugetCache.sh
@@ -4,5 +4,6 @@
  cp ../samples/ControlCatalog.NetCore/bin/Debug/netcoreapp2.0/Avalonia**.dll ~/.nuget/packages/avalonia/$1/lib/netstandard2.0/
  cp ../samples/ControlCatalog.NetCore/bin/Debug/netcoreapp2.0/Avalonia**.dll ~/.nuget/packages/avalonia.gtk3/$1/lib/netstandard2.0/
  cp ../samples/ControlCatalog.NetCore/bin/Debug/netcoreapp2.0/Avalonia**.dll ~/.nuget/packages/avalonia.skia/$1/lib/netstandard2.0/
+ cp ../samples/ControlCatalog.NetCore/bin/Debug/netcoreapp2.0/Avalonia**.dll ~/.nuget/packages/avalonia.native/$1/lib/netstandard2.0/
  
  
diff --git a/src/Avalonia.Controls/ColumnDefinition.cs b/src/Avalonia.Controls/ColumnDefinition.cs
index a6b34f8a16..d316881a05 100644
--- a/src/Avalonia.Controls/ColumnDefinition.cs
+++ b/src/Avalonia.Controls/ColumnDefinition.cs
@@ -88,4 +88,4 @@ namespace Avalonia.Controls
             set { SetValue(WidthProperty, value); }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Avalonia.Controls/Grid.cs b/src/Avalonia.Controls/Grid.cs
index 1a07ccaf7e..b51583d8b3 100644
--- a/src/Avalonia.Controls/Grid.cs
+++ b/src/Avalonia.Controls/Grid.cs
@@ -3,10 +3,13 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
+using System.Reactive.Linq;
 using System.Runtime.CompilerServices;
 using Avalonia.Collections;
 using Avalonia.Controls.Utils;
+using Avalonia.VisualTree;
 using JetBrains.Annotations;
 
 namespace Avalonia.Controls
@@ -44,6 +47,24 @@ namespace Avalonia.Controls
         public static readonly AttachedProperty<int> RowSpanProperty =
             AvaloniaProperty.RegisterAttached<Grid, Control, int>("RowSpan", 1);
 
+        public static readonly AttachedProperty<bool> IsSharedSizeScopeProperty =
+            AvaloniaProperty.RegisterAttached<Grid, Control, bool>("IsSharedSizeScope", false);
+
+        protected override void OnMeasureInvalidated()
+        {
+            base.OnMeasureInvalidated();
+            _sharedSizeHost?.InvalidateMeasure(this);
+        }
+
+        private SharedSizeScopeHost _sharedSizeHost;
+
+        /// <summary>
+        /// Defines the SharedSizeScopeHost private property. 
+        /// The ampersands are used to make accessing the property via xaml inconvenient.
+        /// </summary>
+        internal static readonly AttachedProperty<SharedSizeScopeHost> s_sharedSizeScopeHostProperty =
+            AvaloniaProperty.RegisterAttached<Grid, Control, SharedSizeScopeHost>("&&SharedSizeScopeHost");
+
         private ColumnDefinitions _columnDefinitions;
 
         private RowDefinitions _rowDefinitions;
@@ -51,6 +72,13 @@ namespace Avalonia.Controls
         static Grid()
         {
             AffectsParentMeasure<Grid>(ColumnProperty, ColumnSpanProperty, RowProperty, RowSpanProperty);
+            IsSharedSizeScopeProperty.Changed.AddClassHandler<Control>(IsSharedSizeScopeChanged);
+        }
+
+        public Grid()
+        {
+            this.AttachedToVisualTree += Grid_AttachedToVisualTree;
+            this.DetachedFromVisualTree += Grid_DetachedFromVisualTree;
         }
 
         /// <summary>
@@ -77,6 +105,7 @@ namespace Avalonia.Controls
 
                 _columnDefinitions = value;
                 _columnDefinitions.TrackItemPropertyChanged(_ => InvalidateMeasure());
+                _columnDefinitions.CollectionChanged += (_, __) => InvalidateMeasure();
             }
         }
 
@@ -104,6 +133,7 @@ namespace Avalonia.Controls
 
                 _rowDefinitions = value;
                 _rowDefinitions.TrackItemPropertyChanged(_ => InvalidateMeasure());
+                _rowDefinitions.CollectionChanged += (_, __) => InvalidateMeasure();
             }
         }
 
@@ -271,6 +301,11 @@ namespace Avalonia.Controls
             _rowLayoutCache = rowLayout;
             _columnLayoutCache = columnLayout;
 
+            if (_sharedSizeHost?.ParticipatesInScope(this) ?? false)
+            {
+                _sharedSizeHost.UpdateMeasureStatus(this, rowResult, columnResult);
+            }
+
             return new Size(columnResult.DesiredLength, rowResult.DesiredLength);
 
             // Measure each child only once.
@@ -319,9 +354,21 @@ namespace Avalonia.Controls
             var (safeColumns, safeRows) = GetSafeColumnRows();
             var columnLayout = _columnLayoutCache;
             var rowLayout = _rowLayoutCache;
+
+            var rowCache = _rowMeasureCache;
+            var columnCache = _columnMeasureCache;
+
+            if (_sharedSizeHost?.ParticipatesInScope(this) ?? false)
+            {
+                (rowCache, columnCache) = _sharedSizeHost.HandleArrange(this, _rowMeasureCache, _columnMeasureCache);
+            
+                rowCache = rowLayout.Measure(finalSize.Height, rowCache.LeanLengthList);
+                columnCache = columnLayout.Measure(finalSize.Width, columnCache.LeanLengthList);
+            }
+
             // Calculate for arrange result.
-            var columnResult = columnLayout.Arrange(finalSize.Width, _columnMeasureCache);
-            var rowResult = rowLayout.Arrange(finalSize.Height, _rowMeasureCache);
+            var columnResult = columnLayout.Arrange(finalSize.Width, columnCache);
+            var rowResult = rowLayout.Arrange(finalSize.Height, rowCache);
             // Arrange the children.
             foreach (var child in Children.OfType<Control>())
             {
@@ -350,6 +397,73 @@ namespace Avalonia.Controls
             return finalSize;
         }
 
+        /// <summary>
+        /// Tests whether this grid belongs to a shared size scope.
+        /// </summary>
+        /// <returns>True if the grid is registered in a shared size scope.</returns>
+        internal bool HasSharedSizeScope()
+        {
+            return _sharedSizeHost != null;
+        }
+
+        /// <summary>
+        /// Called when the SharedSizeScope for a given grid has changed.
+        /// Unregisters the grid from it's current scope and finds a new one (if any) 
+        /// </summary>
+        /// <remarks>
+        /// This method, while not efficient, correctly handles nested scopes, with any order of scope changes.
+        /// </remarks>
+        internal void SharedScopeChanged()
+        {
+            _sharedSizeHost?.UnegisterGrid(this);
+
+            _sharedSizeHost = null;
+            var scope = this.GetVisualAncestors().OfType<Control>()
+                .FirstOrDefault(c => c.GetValue(IsSharedSizeScopeProperty));
+
+            if (scope != null)
+            {
+                _sharedSizeHost = scope.GetValue(s_sharedSizeScopeHostProperty);
+                _sharedSizeHost.RegisterGrid(this);
+            }
+
+            InvalidateMeasure();
+        }
+
+        /// <summary>
+        /// Callback when a grid is attached to the visual tree. Finds the innermost SharedSizeScope and registers the grid 
+        /// in it.
+        /// </summary>
+        /// <param name="sender">The source of the event.</param>
+        /// <param name="e">The event arguments.</param>
+        private void Grid_AttachedToVisualTree(object sender, VisualTreeAttachmentEventArgs e)
+        {
+            var scope =
+                new Control[] { this }.Concat(this.GetVisualAncestors().OfType<Control>())
+                    .FirstOrDefault(c => c.GetValue(IsSharedSizeScopeProperty));
+
+            if (_sharedSizeHost != null)
+                throw new AvaloniaInternalException("Shared size scope already present when attaching to visual tree!");
+
+            if (scope != null)
+            {
+                _sharedSizeHost = scope.GetValue(s_sharedSizeScopeHostProperty);
+                _sharedSizeHost.RegisterGrid(this);
+            }
+        }
+
+        /// <summary>
+        /// Callback when a grid is detached from the visual tree. Unregisters the grid from its SharedSizeScope if any.
+        /// </summary>
+        /// <param name="sender">The source of the event.</param>
+        /// <param name="e">The event arguments.</param>
+        private void Grid_DetachedFromVisualTree(object sender, VisualTreeAttachmentEventArgs e)
+        {
+            _sharedSizeHost?.UnegisterGrid(this);
+            _sharedSizeHost = null;
+        }
+
+
         /// <summary>
         /// Get the safe column/columnspan and safe row/rowspan.
         /// This method ensures that none of the children has a column/row outside the bounds of the definitions.
@@ -426,5 +540,41 @@ namespace Avalonia.Controls
 
             return value;
         }
+
+        /// <summary>
+        /// Called when the value of <see cref="Grid.IsSharedSizeScopeProperty"/> changes for a control.
+        /// </summary>
+        /// <param name="source">The control that triggered the change.</param>
+        /// <param name="arg2">Change arguments.</param>
+        private static void IsSharedSizeScopeChanged(Control source, AvaloniaPropertyChangedEventArgs arg2)
+        {
+            var shouldDispose = (arg2.OldValue is bool d) && d;
+            if (shouldDispose)
+            {
+                var host = source.GetValue(s_sharedSizeScopeHostProperty) as SharedSizeScopeHost;
+                if (host == null)
+                    throw new AvaloniaInternalException("SharedScopeHost wasn't set when IsSharedSizeScope was true!");
+                host.Dispose();
+                source.ClearValue(s_sharedSizeScopeHostProperty);
+            }
+
+            var shouldAssign = (arg2.NewValue is bool a) && a;
+            if (shouldAssign)
+            {
+                if (source.GetValue(s_sharedSizeScopeHostProperty) != null)
+                    throw new AvaloniaInternalException("SharedScopeHost was already set when IsSharedSizeScope is only now being set to true!");
+                source.SetValue(s_sharedSizeScopeHostProperty, new SharedSizeScopeHost());
+            }
+
+            // if the scope has changed, notify the descendant grids that they need to update.
+            if (source.GetVisualRoot() != null && shouldAssign || shouldDispose)
+            {
+                var participatingGrids = new[] { source }.Concat(source.GetVisualDescendants()).OfType<Grid>();
+
+                foreach (var grid in participatingGrids)
+                    grid.SharedScopeChanged();
+
+            }
+        }
     }
 }
diff --git a/src/Avalonia.Controls/GridSplitter.cs b/src/Avalonia.Controls/GridSplitter.cs
index 1e4c6f2c2a..304a760216 100644
--- a/src/Avalonia.Controls/GridSplitter.cs
+++ b/src/Avalonia.Controls/GridSplitter.cs
@@ -44,26 +44,52 @@ namespace Avalonia.Controls
 
         protected override void OnDragDelta(VectorEventArgs e)
         {
+            // WPF doesn't change anything when spliter is in the last row/column
+            // but resizes the splitter row/column when it's the first one.
+            // this is different, but more internally consistent.
+            if (_prevDefinition == null || _nextDefinition == null)
+                return;
+
             var delta = _orientation == Orientation.Vertical ? e.Vector.X : e.Vector.Y;
             double max;
             double min;
             GetDeltaConstraints(out min, out max);
             delta = Math.Min(Math.Max(delta, min), max);
-            foreach (var definition in _definitions)
+
+            var prevIsStar = IsStar(_prevDefinition);
+            var nextIsStar = IsStar(_nextDefinition);
+
+            if (prevIsStar && nextIsStar)
             {
-                if (definition == _prevDefinition)
-                {
-                    SetLengthInStars(_prevDefinition, GetActualLength(_prevDefinition) + delta);
-                }
-                else if (definition == _nextDefinition)
-                {
-                    SetLengthInStars(_nextDefinition, GetActualLength(_nextDefinition) - delta);
-                }
-                else if (IsStar(definition))
+                foreach (var definition in _definitions)
                 {
-                    SetLengthInStars(definition, GetActualLength(definition)); // same size but in stars.
+                    if (definition == _prevDefinition)
+                    {
+                        SetLengthInStars(_prevDefinition, GetActualLength(_prevDefinition) + delta);
+                    }
+                    else if (definition == _nextDefinition)
+                    {
+                        SetLengthInStars(_nextDefinition, GetActualLength(_nextDefinition) - delta);
+                    }
+                    else if (IsStar(definition))
+                    {
+                        SetLengthInStars(definition, GetActualLength(definition)); // same size but in stars.
+                    }
                 }
             }
+            else if (prevIsStar)
+            {
+                SetLength(_nextDefinition, GetActualLength(_nextDefinition) - delta);
+            }
+            else if (nextIsStar)
+            {
+                SetLength(_prevDefinition, GetActualLength(_prevDefinition) + delta);
+            }
+            else
+            {
+                SetLength(_prevDefinition, GetActualLength(_prevDefinition) + delta);
+                SetLength(_nextDefinition, GetActualLength(_nextDefinition) - delta);
+            }
         }
 
         private double GetActualLength(DefinitionBase definition)
@@ -71,7 +97,7 @@ namespace Avalonia.Controls
             if (definition == null)
                 return 0;
             var columnDefinition = definition as ColumnDefinition;
-            return columnDefinition?.ActualWidth ?? ((RowDefinition) definition).ActualHeight;
+            return columnDefinition?.ActualWidth ?? ((RowDefinition)definition).ActualHeight;
         }
 
         private double GetMinLength(DefinitionBase definition)
@@ -79,7 +105,7 @@ namespace Avalonia.Controls
             if (definition == null)
                 return 0;
             var columnDefinition = definition as ColumnDefinition;
-            return columnDefinition?.MinWidth ?? ((RowDefinition) definition).MinHeight;
+            return columnDefinition?.MinWidth ?? ((RowDefinition)definition).MinHeight;
         }
 
         private double GetMaxLength(DefinitionBase definition)
@@ -87,13 +113,13 @@ namespace Avalonia.Controls
             if (definition == null)
                 return 0;
             var columnDefinition = definition as ColumnDefinition;
-            return columnDefinition?.MaxWidth ?? ((RowDefinition) definition).MaxHeight;
+            return columnDefinition?.MaxWidth ?? ((RowDefinition)definition).MaxHeight;
         }
 
         private bool IsStar(DefinitionBase definition)
         {
             var columnDefinition = definition as ColumnDefinition;
-            return columnDefinition?.Width.IsStar ?? ((RowDefinition) definition).Height.IsStar;
+            return columnDefinition?.Width.IsStar ?? ((RowDefinition)definition).Height.IsStar;
         }
 
         private void SetLengthInStars(DefinitionBase definition, double value)
@@ -105,7 +131,20 @@ namespace Avalonia.Controls
             }
             else
             {
-                ((RowDefinition) definition).Height = new GridLength(value, GridUnitType.Star);
+                ((RowDefinition)definition).Height = new GridLength(value, GridUnitType.Star);
+            }
+        }
+
+        private void SetLength(DefinitionBase definition, double value)
+        {
+            var columnDefinition = definition as ColumnDefinition;
+            if (columnDefinition != null)
+            {
+                columnDefinition.Width = new GridLength(value);
+            }
+            else
+            {
+                ((RowDefinition)definition).Height = new GridLength(value);
             }
         }
 
@@ -160,7 +199,7 @@ namespace Avalonia.Controls
             }
             if (_grid.Children.OfType<Control>() // Decision based on other controls in the same column
                 .Where(c => Grid.GetColumn(c) == col)
-                .Any(c => c.GetType() != typeof (GridSplitter)))
+                .Any(c => c.GetType() != typeof(GridSplitter)))
             {
                 return Orientation.Horizontal;
             }
diff --git a/src/Avalonia.Controls/Platform/IWindowImpl.cs b/src/Avalonia.Controls/Platform/IWindowImpl.cs
index f1f3925133..2ddc5a5c85 100644
--- a/src/Avalonia.Controls/Platform/IWindowImpl.cs
+++ b/src/Avalonia.Controls/Platform/IWindowImpl.cs
@@ -30,10 +30,7 @@ namespace Avalonia.Platform
         /// <summary>
         /// Shows the window as a dialog.
         /// </summary>
-        /// <returns>
-        /// An <see cref="IDisposable"/> that should be used to close the window.
-        /// </returns>
-        IDisposable ShowDialog();
+        void ShowDialog(IWindowImpl parent);
 
         /// <summary>
         /// Enables or disables system window decorations (title bar, buttons, etc)
diff --git a/src/Avalonia.Controls/Primitives/PopupRoot.cs b/src/Avalonia.Controls/Primitives/PopupRoot.cs
index fdec9febd3..286f7df3b9 100644
--- a/src/Avalonia.Controls/Primitives/PopupRoot.cs
+++ b/src/Avalonia.Controls/Primitives/PopupRoot.cs
@@ -84,8 +84,10 @@ namespace Avalonia.Controls.Primitives
 
             if (screen != null)
             {
-                var screenX = Position.X + Bounds.Width - screen.Bounds.X;
-                var screenY = Position.Y + Bounds.Height - screen.Bounds.Y;
+                var scaling = VisualRoot.RenderScaling;
+
+                var screenX = Position.X + (Bounds.Width * scaling) - screen.Bounds.X;
+                var screenY = Position.Y + (Bounds.Height * scaling) - screen.Bounds.Y;
 
                 if (screenX > screen.Bounds.Width)
                 {
diff --git a/src/Avalonia.Controls/SystemDialog.cs b/src/Avalonia.Controls/SystemDialog.cs
index 9a739d6556..e7cb4763ed 100644
--- a/src/Avalonia.Controls/SystemDialog.cs
+++ b/src/Avalonia.Controls/SystemDialog.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
@@ -18,28 +19,40 @@ namespace Avalonia.Controls
 
     public class SaveFileDialog : FileDialog
     {
-        public string DefaultExtension { get; set; }        
+        public string DefaultExtension { get; set; }
 
-        public async Task<string> ShowAsync(Window window)
-            =>
-                ((await AvaloniaLocator.Current.GetService<ISystemDialogImpl>().ShowFileDialogAsync(this, window?.PlatformImpl)) ??
-                 new string[0]).FirstOrDefault();
+        public async Task<string> ShowAsync(Window parent)
+        {
+            if(parent == null)
+                throw new ArgumentNullException(nameof(parent));
+            return ((await AvaloniaLocator.Current.GetService<ISystemDialogImpl>()
+                 .ShowFileDialogAsync(this, parent?.PlatformImpl)) ??
+             new string[0]).FirstOrDefault();
+        }
     }
 
     public class OpenFileDialog : FileDialog
     {
         public bool AllowMultiple { get; set; }
 
-        public Task<string[]> ShowAsync(Window window = null)
-            => AvaloniaLocator.Current.GetService<ISystemDialogImpl>().ShowFileDialogAsync(this, window?.PlatformImpl);
+        public Task<string[]> ShowAsync(Window parent)
+        {
+            if(parent == null)
+                throw new ArgumentNullException(nameof(parent));
+            return AvaloniaLocator.Current.GetService<ISystemDialogImpl>().ShowFileDialogAsync(this, parent?.PlatformImpl);
+        }
     }
 
     public class OpenFolderDialog : FileSystemDialog
     {
         public string DefaultDirectory { get; set; }
 
-        public Task<string> ShowAsync(Window window = null)
-               => AvaloniaLocator.Current.GetService<ISystemDialogImpl>().ShowFolderDialogAsync(this, window?.PlatformImpl);
+        public Task<string> ShowAsync(Window parent)
+        {
+            if(parent == null)
+                throw new ArgumentNullException(nameof(parent));
+            return AvaloniaLocator.Current.GetService<ISystemDialogImpl>().ShowFolderDialogAsync(this, parent?.PlatformImpl);
+        }
     }
 
     public abstract class SystemDialog
diff --git a/src/Avalonia.Controls/TextBox.cs b/src/Avalonia.Controls/TextBox.cs
index dc2884b36b..04b088e35c 100644
--- a/src/Avalonia.Controls/TextBox.cs
+++ b/src/Avalonia.Controls/TextBox.cs
@@ -262,7 +262,6 @@ namespace Avalonia.Controls
         protected override void OnTemplateApplied(TemplateAppliedEventArgs e)
         {
             _presenter = e.NameScope.Get<TextPresenter>("PART_TextPresenter");
-            _presenter.Cursor = new Cursor(StandardCursorType.Ibeam);
 
             if (IsFocused)
             {
diff --git a/src/Avalonia.Controls/Utils/GridLayout.cs b/src/Avalonia.Controls/Utils/GridLayout.cs
index 363428b289..7704228a4e 100644
--- a/src/Avalonia.Controls/Utils/GridLayout.cs
+++ b/src/Avalonia.Controls/Utils/GridLayout.cs
@@ -143,14 +143,17 @@ namespace Avalonia.Controls.Utils
         /// <param name="containerLength">
         /// The container length. Usually, it is the constraint of the <see cref="Layoutable.MeasureOverride"/> method.
         /// </param>
+        /// <param name="conventions">
+        /// Overriding conventions that allows the algorithm to handle external inputa 
+        /// </param>
         /// <returns>
         /// The measured result that containing the desired size and all the column/row lengths.
         /// </returns>
         [NotNull, Pure]
-        internal MeasureResult Measure(double containerLength)
+        internal MeasureResult Measure(double containerLength, IReadOnlyList<LengthConvention> conventions = null)
         {
             // Prepare all the variables that this method needs to use.
-            var conventions = _conventions.Select(x => x.Clone()).ToList();
+            conventions = conventions ?? _conventions.Select(x => x.Clone()).ToList();
             var starCount = conventions.Where(x => x.Length.IsStar).Sum(x => x.Length.Value);
             var aggregatedLength = 0.0;
             double starUnitLength;
@@ -248,7 +251,7 @@ namespace Avalonia.Controls.Utils
             // | min | max |     |           | min |     |  min max  | max |
             // |#des#| fix |#des#| fix | fix | fix | fix |   #des#   |#des#|
 
-            var desiredStarMin = AggregateAdditionalConventionsForStars(conventions);
+            var (minLengths, desiredStarMin) = AggregateAdditionalConventionsForStars(conventions);
             aggregatedLength += desiredStarMin;
 
             // M6/7. Determine the desired length of the grid for current container length. Its value is stored in desiredLength.
@@ -282,7 +285,7 @@ namespace Avalonia.Controls.Utils
 
             // Returns the measuring result.
             return new MeasureResult(containerLength, desiredLength, greedyDesiredLength,
-                conventions, dynamicConvention);
+                conventions, dynamicConvention, minLengths);
         }
 
         /// <summary>
@@ -306,14 +309,14 @@ namespace Avalonia.Controls.Utils
             if (finalLength - measure.ContainerLength > LayoutTolerance)
             {
                 // If the final length is larger, we will rerun the whole measure.
-                measure = Measure(finalLength);
+                measure = Measure(finalLength, measure.LeanLengthList);
             }
             else if (finalLength - measure.ContainerLength < -LayoutTolerance)
             {
                 // If the final length is smaller, we measure the M6/6 procedure only.
                 var dynamicConvention = ExpandStars(measure.LeanLengthList, finalLength);
                 measure = new MeasureResult(finalLength, measure.DesiredLength, measure.GreedyDesiredLength,
-                    measure.LeanLengthList, dynamicConvention);
+                    measure.LeanLengthList, dynamicConvention, measure.MinLengths);
             }
 
             return new ArrangeResult(measure.LengthList);
@@ -370,7 +373,7 @@ namespace Avalonia.Controls.Utils
         /// <param name="conventions">All the conventions that have almost been fixed except the rest *.</param>
         /// <returns>The total desired length of all the * length.</returns>
         [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private double AggregateAdditionalConventionsForStars(
+        private (List<double>, double) AggregateAdditionalConventionsForStars(
             IReadOnlyList<LengthConvention> conventions)
         {
             // 1. Determine all one-span column's desired widths or row's desired heights.
@@ -403,7 +406,7 @@ namespace Avalonia.Controls.Utils
                 lengthList[group.Key] = Math.Max(lengthList[group.Key], length > 0 ? length : 0);
             }
 
-            return lengthList.Sum() - fixedLength;
+            return (lengthList, lengthList.Sum() - fixedLength);
         }
 
         /// <summary>
@@ -638,13 +641,14 @@ namespace Avalonia.Controls.Utils
             /// Initialize a new instance of <see cref="MeasureResult"/>.
             /// </summary>
             internal MeasureResult(double containerLength, double desiredLength, double greedyDesiredLength,
-                IReadOnlyList<LengthConvention> leanConventions, IReadOnlyList<double> expandedConventions)
+                IReadOnlyList<LengthConvention> leanConventions, IReadOnlyList<double> expandedConventions, IReadOnlyList<double> minLengths)
             {
                 ContainerLength = containerLength;
                 DesiredLength = desiredLength;
                 GreedyDesiredLength = greedyDesiredLength;
                 LeanLengthList = leanConventions;
                 LengthList = expandedConventions;
+                MinLengths = minLengths;
             }
 
             /// <summary>
@@ -674,6 +678,7 @@ namespace Avalonia.Controls.Utils
             /// Gets the length list for each column/row.
             /// </summary>
             public IReadOnlyList<double> LengthList { get; }
+            public IReadOnlyList<double> MinLengths { get; }
         }
 
         /// <summary>
diff --git a/src/Avalonia.Controls/Utils/SharedSizeScopeHost.cs b/src/Avalonia.Controls/Utils/SharedSizeScopeHost.cs
new file mode 100644
index 0000000000..8553165e4b
--- /dev/null
+++ b/src/Avalonia.Controls/Utils/SharedSizeScopeHost.cs
@@ -0,0 +1,651 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Linq;
+using System.Reactive.Disposables;
+using System.Reactive.Subjects;
+using Avalonia.Collections;
+using Avalonia.Controls.Utils;
+using Avalonia.Layout;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Controls
+{
+    /// <summary>
+    /// Shared size scope implementation.
+    /// Shares the size information between participating grids.
+    /// An instance of this class is attached to every <see cref="Control"/> that has its
+    /// IsSharedSizeScope property set to true.
+    /// </summary>
+    internal sealed class SharedSizeScopeHost : IDisposable
+    {
+        private enum MeasurementState
+        {
+            Invalidated,
+            Measuring,
+            Cached
+        }
+
+        /// <summary>
+        /// Class containing the measured rows/columns for a single grid.
+        /// Monitors changes to the row/column collections as well as the SharedSizeGroup changes
+        /// for the individual items in those collections.
+        /// Notifies the <see cref="SharedSizeScopeHost"/> of SharedSizeGroup changes.
+        /// </summary>
+        private sealed class MeasurementCache : IDisposable
+        {
+            readonly CompositeDisposable _subscriptions;
+            readonly Subject<(string, string, MeasurementResult)> _groupChanged = new Subject<(string, string, MeasurementResult)>();
+
+            public ISubject<(string oldName, string newName, MeasurementResult result)> GroupChanged => _groupChanged;
+
+            public MeasurementCache(Grid grid)
+            {
+                Grid = grid;
+                Results = grid.RowDefinitions.Cast<DefinitionBase>()
+                    .Concat(grid.ColumnDefinitions)
+                    .Select(d => new MeasurementResult(grid, d))
+                    .ToList();
+
+                grid.RowDefinitions.CollectionChanged += DefinitionsCollectionChanged;
+                grid.ColumnDefinitions.CollectionChanged += DefinitionsCollectionChanged;
+
+
+                _subscriptions = new CompositeDisposable(
+                    Disposable.Create(() => grid.RowDefinitions.CollectionChanged -= DefinitionsCollectionChanged),
+                    Disposable.Create(() => grid.ColumnDefinitions.CollectionChanged -= DefinitionsCollectionChanged),
+                    grid.RowDefinitions.TrackItemPropertyChanged(DefinitionPropertyChanged),
+                    grid.ColumnDefinitions.TrackItemPropertyChanged(DefinitionPropertyChanged));
+
+            }
+
+            // method to be hooked up once RowDefinitions/ColumnDefinitions collections can be replaced on a grid
+            private void DefinitionsChanged(object sender, AvaloniaPropertyChangedEventArgs e)
+            {
+                // route to collection changed as a Reset.
+                DefinitionsCollectionChanged(null, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
+            }
+
+            private void DefinitionPropertyChanged(Tuple<object, PropertyChangedEventArgs> propertyChanged)
+            {
+                if (propertyChanged.Item2.PropertyName == nameof(DefinitionBase.SharedSizeGroup))
+                {
+                    var result = Results.Single(mr => ReferenceEquals(mr.Definition, propertyChanged.Item1));
+                    var oldName = result.SizeGroup?.Name;
+                    var newName = (propertyChanged.Item1 as DefinitionBase).SharedSizeGroup;
+                    _groupChanged.OnNext((oldName, newName, result));
+                }
+            }
+
+            private void DefinitionsCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
+            {
+                int offset = 0;
+                if (sender is ColumnDefinitions)
+                    offset = Grid.RowDefinitions.Count;
+
+                var newItems = e.NewItems?.OfType<DefinitionBase>().Select(db => new MeasurementResult(Grid, db)).ToList() ?? new List<MeasurementResult>();
+                var oldItems = e.OldStartingIndex >= 0 
+                                    ? Results.GetRange(e.OldStartingIndex + offset, e.OldItems.Count) 
+                                    : new List<MeasurementResult>();
+
+                void NotifyNewItems()
+                {
+                    foreach (var item in newItems)
+                    {
+                        if (string.IsNullOrEmpty(item.Definition.SharedSizeGroup))
+                            continue;
+
+                        _groupChanged.OnNext((null, item.Definition.SharedSizeGroup, item));
+                    }
+                }
+
+                void NotifyOldItems()
+                {
+                    foreach (var item in oldItems)
+                    {
+                        if (string.IsNullOrEmpty(item.Definition.SharedSizeGroup))
+                            continue;
+
+                        _groupChanged.OnNext((item.Definition.SharedSizeGroup, null, item));
+                    }
+                }
+
+                switch (e.Action)
+                {
+                    case NotifyCollectionChangedAction.Add:
+                        Results.InsertRange(e.NewStartingIndex + offset, newItems);
+                        NotifyNewItems();
+                        break;
+
+                    case NotifyCollectionChangedAction.Remove:
+                        Results.RemoveRange(e.OldStartingIndex + offset, oldItems.Count);
+                        NotifyOldItems();
+                        break;
+
+                    case NotifyCollectionChangedAction.Move:
+                        Results.RemoveRange(e.OldStartingIndex + offset, oldItems.Count);
+                        Results.InsertRange(e.NewStartingIndex + offset, oldItems);
+                        break;
+
+                    case NotifyCollectionChangedAction.Replace:
+                        Results.RemoveRange(e.OldStartingIndex + offset, oldItems.Count);
+                        Results.InsertRange(e.NewStartingIndex + offset, newItems);
+
+                        NotifyOldItems();
+                        NotifyNewItems();
+
+                        break;
+
+                    case NotifyCollectionChangedAction.Reset:
+                        oldItems = Results;
+                        newItems = Results = Grid.RowDefinitions.Cast<DefinitionBase>()
+                            .Concat(Grid.ColumnDefinitions)
+                            .Select(d => new MeasurementResult(Grid, d))
+                            .ToList();
+                        NotifyOldItems();
+                        NotifyNewItems();
+
+                        break;
+                }
+            }
+
+
+            /// <summary>
+            /// Updates the Results collection with Grid Measure results. 
+            /// </summary>
+            /// <param name="rowResult">Result of the GridLayout.Measure method for the RowDefinitions in the grid.</param>
+            /// <param name="columnResult">Result of the GridLayout.Measure method for the ColumnDefinitions in the grid.</param>
+            public void UpdateMeasureResult(GridLayout.MeasureResult rowResult, GridLayout.MeasureResult columnResult)
+            {
+                MeasurementState = MeasurementState.Cached;
+                for (int i = 0; i < Grid.RowDefinitions.Count; i++)
+                {
+                    Results[i].MeasuredResult = rowResult.LengthList[i];
+                    Results[i].MinLength = rowResult.MinLengths[i];
+                }
+
+                for (int i = 0; i < Grid.ColumnDefinitions.Count; i++)
+                {
+                    Results[i + Grid.RowDefinitions.Count].MeasuredResult = columnResult.LengthList[i];
+                    Results[i + Grid.RowDefinitions.Count].MinLength = columnResult.MinLengths[i];
+                }
+            }
+
+            /// <summary>
+            /// Clears the measurement cache, in preparation for the Measure pass.
+            /// </summary>
+            public void InvalidateMeasure()
+            {
+                var newItems = new List<MeasurementResult>();
+                var oldItems = new List<MeasurementResult>();
+
+                MeasurementState = MeasurementState.Invalidated;
+
+                Results.ForEach(r =>
+                {
+                    r.MeasuredResult = double.NaN;
+                    r.SizeGroup?.Reset();
+                });
+            }
+
+            /// <summary>
+            /// Clears the <see cref="IObservable{T}"/> subscriptions.
+            /// </summary>
+            public void Dispose()
+            {
+                _subscriptions.Dispose();
+                _groupChanged.OnCompleted();
+            }
+
+            /// <summary>
+            /// Gets the <see cref="Grid"/> for which this cache has been created.
+            /// </summary>
+            public Grid Grid { get; }
+            
+            /// <summary>
+            /// Gets the <see cref="MeasurementState"/> of this cache.
+            /// </summary>
+            public MeasurementState MeasurementState { get; private set; }
+
+            /// <summary>
+            /// Gets the list of <see cref="MeasurementResult"/> instances.
+            /// </summary>
+            /// <remarks>
+            /// The list is a 1-1 map of the concatenation of RowDefinitions and ColumnDefinitions
+            /// </remarks>
+            public List<MeasurementResult> Results { get; private set; }
+        }
+
+
+        /// <summary>
+        /// Class containing the Measure result for a single Row/Column in a grid.
+        /// </summary>
+        private class MeasurementResult
+        {
+            public MeasurementResult(Grid owningGrid, DefinitionBase definition)
+            {
+                OwningGrid = owningGrid;
+                Definition = definition;
+                MeasuredResult = double.NaN;
+            }
+
+            /// <summary>
+            /// Gets the <see cref="RowDefinition"/>/<see cref="ColumnDefinition"/> related to this <see cref="MeasurementResult"/>
+            /// </summary>
+            public DefinitionBase Definition { get; }
+            
+            /// <summary>
+            /// Gets or sets the actual result of the Measure operation for this column.
+            /// </summary>
+            public double MeasuredResult { get; set; }
+            
+            /// <summary>
+            /// Gets or sets the Minimum constraint for a Row/Column - relevant for star Rows/Columns in unconstrained grids.
+            /// </summary>
+            public double MinLength { get; set; }
+            
+            /// <summary>
+            /// Gets or sets the <see cref="Group"/> that this result belongs to.
+            /// </summary>
+            public Group SizeGroup { get; set; }
+            
+            /// <summary>
+            /// Gets the Grid that is the parent of the Row/Column
+            /// </summary>
+            public Grid OwningGrid { get; }
+
+            /// <summary>
+            /// Calculates the effective length that this Row/Column wishes to enforce in the SharedSizeGroup.
+            /// </summary>
+            /// <returns>A tuple of length and the priority in the shared size group.</returns>
+            public (double length, int priority) GetPriorityLength()
+            {
+                var length = (Definition as ColumnDefinition)?.Width ?? ((RowDefinition)Definition).Height;
+
+                if (length.IsAbsolute)
+                    return (MeasuredResult, 1);
+                if (length.IsAuto)
+                    return (MeasuredResult, 2);
+                if (MinLength > 0)
+                    return (MinLength, 3);
+                return (MeasuredResult, 4);
+            }
+        }
+
+        /// <summary>
+        /// Visitor class used to gather the final length for a given SharedSizeGroup.
+        /// </summary>
+        /// <remarks>
+        /// The values are applied according to priorities defined in <see cref="MeasurementResult.GetPriorityLength"/>.
+        /// </remarks>
+        private class LentgthGatherer
+        {
+            /// <summary>
+            /// Gets the final Length to be applied to every Row/Column in a SharedSizeGroup
+            /// </summary>
+            public double Length { get; private set; }
+            private int gatheredPriority = 6;
+
+            /// <summary>
+            /// Visits the <paramref name="result"/> applying the result of <see cref="MeasurementResult.GetPriorityLength"/> to its internal cache.
+            /// </summary>
+            /// <param name="result">The <see cref="MeasurementResult"/> instance to visit.</param>
+            public void Visit(MeasurementResult result)
+            {
+                var (length, priority) = result.GetPriorityLength();
+
+                if (gatheredPriority < priority)
+                    return;
+
+                gatheredPriority = priority;
+                if (gatheredPriority == priority)
+                {
+                    Length = Math.Max(length,Length);
+                }
+                else
+                {
+                    Length = length;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Representation of a SharedSizeGroup, containing Rows/Columns with the same SharedSizeGroup property value.
+        /// </summary>
+        private class Group
+        {
+            private double? cachedResult;
+            private List<MeasurementResult> _results = new List<MeasurementResult>(); 
+
+            /// <summary>
+            /// Gets the name of the SharedSizeGroup.
+            /// </summary>
+            public string Name { get; }
+
+            public Group(string name)
+            {
+                Name = name;
+            }
+
+            /// <summary>
+            /// Gets the collection of the <see cref="MeasurementResult"/> instances.
+            /// </summary>
+            public IReadOnlyList<MeasurementResult> Results => _results;
+
+            /// <summary>
+            /// Gets the final, calculated length for all Rows/Columns in the SharedSizeGroup.
+            /// </summary>
+            public double CalculatedLength => (cachedResult ?? (cachedResult = Gather())).Value;
+
+            /// <summary>
+            /// Clears the previously cached result in preparation for measurement.
+            /// </summary>
+            public void Reset()
+            {
+                cachedResult = null;
+            }
+
+            /// <summary>
+            /// Ads a measurement result to this group and sets it's <see cref="MeasurementResult.SizeGroup"/> property
+            /// to this instance.
+            /// </summary>
+            /// <param name="result">The <see cref="MeasurementResult"/> to include in this group.</param>
+            public void Add(MeasurementResult result)
+            {
+                if (_results.Contains(result))
+                    throw new AvaloniaInternalException(
+                        $"SharedSizeScopeHost: Invalid call to Group.Add - The SharedSizeGroup {Name} already contains the passed result");
+
+                result.SizeGroup = this;
+                _results.Add(result);
+            }
+
+            /// <summary>
+            /// Removes the measurement result from this group and clears its <see cref="MeasurementResult.SizeGroup"/> value.
+            /// </summary>
+            /// <param name="result">The <see cref="MeasurementResult"/> to clear.</param>
+            public void Remove(MeasurementResult result)
+            {
+                if (!_results.Contains(result))
+                    throw new AvaloniaInternalException(
+                        $"SharedSizeScopeHost: Invalid call to Group.Remove - The SharedSizeGroup {Name} does not contain the passed result");
+                result.SizeGroup = null;
+                _results.Remove(result);
+            }
+
+
+            private double Gather()
+            {
+                var visitor = new LentgthGatherer();
+
+                _results.ForEach(visitor.Visit);
+
+                return visitor.Length;
+            }
+        }
+
+        private readonly AvaloniaList<MeasurementCache> _measurementCaches = new AvaloniaList<MeasurementCache>();
+        private readonly Dictionary<string, Group> _groups = new Dictionary<string, Group>();
+        private bool _invalidating;
+
+        /// <summary>
+        /// Removes the SharedSizeScope and notifies all affected grids of the change.
+        /// </summary>
+        public void Dispose()
+        {
+            while (_measurementCaches.Any())
+                _measurementCaches[0].Grid.SharedScopeChanged();
+        }
+
+        /// <summary>
+        /// Registers the grid in this SharedSizeScope, to be called when the grid is added to the visual tree. 
+        /// </summary>
+        /// <param name="toAdd">The <see cref="Grid"/> to add to this scope.</param>
+        internal void RegisterGrid(Grid toAdd)
+        {
+            if (_measurementCaches.Any(mc => ReferenceEquals(mc.Grid, toAdd)))
+                throw new AvaloniaInternalException("SharedSizeScopeHost: tried to register a grid twice!");
+
+            var cache = new MeasurementCache(toAdd);
+            _measurementCaches.Add(cache);
+            AddGridToScopes(cache);
+        }
+
+        /// <summary>
+        /// Removes the registration for a grid in this SharedSizeScope.
+        /// </summary>
+        /// <param name="toRemove">The <see cref="Grid"/> to remove.</param>
+        internal void UnegisterGrid(Grid toRemove)
+        {
+            var cache = _measurementCaches.FirstOrDefault(mc => ReferenceEquals(mc.Grid, toRemove));
+            if (cache == null)
+                throw new AvaloniaInternalException("SharedSizeScopeHost: tried to unregister a grid that wasn't registered before!");
+
+            _measurementCaches.Remove(cache);
+            RemoveGridFromScopes(cache);
+            cache.Dispose();
+        }
+
+        /// <summary>
+        /// Helper method to check if a grid needs to forward its Mesure results to, and requrest Arrange results from this scope.
+        /// </summary>
+        /// <param name="toCheck">The <see cref="Grid"/> that should be checked.</param>
+        /// <returns>True if the grid should forward its calls.</returns>
+        internal bool ParticipatesInScope(Grid toCheck)
+        {
+            return _measurementCaches.FirstOrDefault(mc => ReferenceEquals(mc.Grid, toCheck))
+                                    ?.Results.Any(r => r.SizeGroup != null) ?? false;
+        }
+
+        /// <summary>
+        /// Notifies the SharedSizeScope that a grid had requested its measurement to be invalidated.
+        /// Forwards the same call to all affected grids in this scope.
+        /// </summary>
+        /// <param name="grid">The <see cref="Grid"/> that had it's Measure invalidated.</param>
+        internal void InvalidateMeasure(Grid grid)
+        {
+            // prevent stack overflow
+            if (_invalidating)
+                return;
+            _invalidating = true;
+
+            InvalidateMeasureImpl(grid);
+
+            _invalidating = false;
+        }
+
+        /// <summary>
+        /// Updates the measurement cache with the results of the <paramref name="grid"/> measurement pass.
+        /// </summary>
+        /// <param name="grid">The <see cref="Grid"/> that has been measured.</param>
+        /// <param name="rowResult">Measurement result for the grid's <see cref="RowDefinitions"/></param>
+        /// <param name="columnResult">Measurement result for the grid's <see cref="ColumnDefinitions"/></param>
+        internal void UpdateMeasureStatus(Grid grid, GridLayout.MeasureResult rowResult, GridLayout.MeasureResult columnResult)
+        {
+            var cache = _measurementCaches.FirstOrDefault(mc => ReferenceEquals(mc.Grid, grid));
+            if (cache == null)
+                throw new AvaloniaInternalException("SharedSizeScopeHost: Attempted to update measurement status for a grid that wasn't registered!");
+
+            cache.UpdateMeasureResult(rowResult, columnResult);
+        }
+
+        /// <summary>
+        /// Calculates the measurement result including the impact of any SharedSizeGroups that might affect this grid.
+        /// </summary>
+        /// <param name="grid">The <see cref="Grid"/> that is being Arranged</param>
+        /// <param name="rowResult">The <paramref name="grid"/>'s cached measurement result.</param>
+        /// <param name="columnResult">The <paramref name="grid"/>'s cached measurement result.</param>
+        /// <returns>Row and column measurement result updated with the SharedSizeScope constraints.</returns>
+        internal (GridLayout.MeasureResult, GridLayout.MeasureResult) HandleArrange(Grid grid, GridLayout.MeasureResult rowResult, GridLayout.MeasureResult columnResult)
+        {
+            return (
+                 Arrange(grid.RowDefinitions, rowResult),
+                 Arrange(grid.ColumnDefinitions, columnResult)
+                 );
+        }
+
+        /// <summary>
+        /// Invalidates the measure of all grids affected by the SharedSizeGroups contained within.
+        /// </summary>
+        /// <param name="grid">The <see cref="Grid"/> that is being invalidated.</param>
+        private void InvalidateMeasureImpl(Grid grid)
+        {
+            var cache = _measurementCaches.FirstOrDefault(mc => ReferenceEquals(mc.Grid, grid));
+
+            if (cache == null)
+                throw new AvaloniaInternalException(
+                    $"SharedSizeScopeHost: InvalidateMeasureImpl - called with a grid not present in the internal cache");
+
+            // already invalidated the cache, early out.
+            if (cache.MeasurementState == MeasurementState.Invalidated)
+                return;
+
+            // we won't calculate, so we should not invalidate.
+            if (!ParticipatesInScope(grid))
+                return;
+
+            cache.InvalidateMeasure();
+
+            // maybe there is a condition to only call arrange on some of the calls?
+            grid.InvalidateMeasure();
+
+            // find all the scopes within the invalidated grid
+            var scopeNames = cache.Results
+                                  .Where(mr => mr.SizeGroup != null)
+                                  .Select(mr => mr.SizeGroup.Name)
+                                  .Distinct();
+            // find all grids related to those scopes
+            var otherGrids = scopeNames.SelectMany(sn => _groups[sn].Results)
+                                       .Select(r => r.OwningGrid)
+                                       .Where(g => g.IsMeasureValid)
+                                       .Distinct();
+
+            // invalidate them as well
+            foreach (var otherGrid in otherGrids)
+            {
+                InvalidateMeasureImpl(otherGrid);
+            }
+        }
+
+        /// <summary>
+        /// <see cref="IObserver{T}"/> callback notifying the scope that a <see cref="MeasurementResult"/> has changed its
+        /// SharedSizeGroup
+        /// </summary>
+        /// <param name="change">Old and New name (either can be null) of the SharedSizeGroup, as well as the result.</param>
+        private void SharedGroupChanged((string oldName, string newName, MeasurementResult result) change)
+        {
+            RemoveFromGroup(change.oldName, change.result);
+            AddToGroup(change.newName, change.result);
+        }
+
+        /// <summary>
+        /// Handles the impact of SharedSizeGroups on the Arrange of <see cref="RowDefinitions"/>/<see cref="ColumnDefinitions"/>
+        /// </summary>
+        /// <param name="definitions">Rows/Columns that were measured</param>
+        /// <param name="measureResult">The initial measurement result.</param>
+        /// <returns>Modified measure result</returns>
+        private GridLayout.MeasureResult Arrange(IReadOnlyList<DefinitionBase> definitions, GridLayout.MeasureResult measureResult)
+        {
+            var conventions = measureResult.LeanLengthList.ToList();
+            var lengths = measureResult.LengthList.ToList();
+            var desiredLength = 0.0;
+            for (int i = 0; i < definitions.Count; i++)
+            {
+                var definition = definitions[i];
+
+                // for empty SharedSizeGroups pass on unmodified result.
+                if (string.IsNullOrEmpty(definition.SharedSizeGroup))
+                {
+                    desiredLength += measureResult.LengthList[i];
+                    continue;
+                }
+
+                var group = _groups[definition.SharedSizeGroup];
+                // Length calculated over all Definitions participating in a SharedSizeGroup.
+                var length = group.CalculatedLength;
+
+                conventions[i] = new GridLayout.LengthConvention(
+                    new GridLength(length),
+                    measureResult.LeanLengthList[i].MinLength,
+                    measureResult.LeanLengthList[i].MaxLength
+                );
+                lengths[i] = length;
+                desiredLength += length;
+            }
+
+            return new GridLayout.MeasureResult(
+                    measureResult.ContainerLength,
+                    desiredLength,
+                    measureResult.GreedyDesiredLength,//??
+                    conventions,
+                    lengths,
+                    measureResult.MinLengths);
+        }
+
+        /// <summary>
+        /// Adds all measurement results for a grid to their repsective scopes.
+        /// </summary>
+        /// <param name="cache">The <see cref="MeasurementCache"/> for a grid to be added.</param>
+        private void AddGridToScopes(MeasurementCache cache)
+        {
+            cache.GroupChanged.Subscribe(SharedGroupChanged);
+
+            foreach (var result in cache.Results)
+            {
+                var scopeName = result.Definition.SharedSizeGroup;
+                AddToGroup(scopeName, result);
+            }
+        }
+
+        /// <summary>
+        /// Handles adding the <see cref="MeasurementResult"/> to a SharedSizeGroup.
+        /// Does nothing for empty SharedSizeGroups.
+        /// </summary>
+        /// <param name="scopeName">The name (can be null or empty) of the group to add the <paramref name="result"/> to.</param>
+        /// <param name="result">The <see cref="MeasurementResult"/> to add to a scope.</param>
+        private void AddToGroup(string scopeName, MeasurementResult result)
+        {
+            if (string.IsNullOrEmpty(scopeName))
+                return;
+
+            if (!_groups.TryGetValue(scopeName, out var group))
+                _groups.Add(scopeName, group = new Group(scopeName));
+
+            group.Add(result);
+        }
+
+        /// <summary>
+        /// Removes all measurement results for a grid from their respective scopes.
+        /// </summary>
+        /// <param name="cache">The <see cref="MeasurementCache"/> for a grid to be removed.</param>
+        private void RemoveGridFromScopes(MeasurementCache cache)
+        {
+            foreach (var result in cache.Results)
+            {
+                var scopeName = result.Definition.SharedSizeGroup;
+                RemoveFromGroup(scopeName, result);
+            }
+        }
+
+        /// <summary>
+        /// Handles removing the <see cref="MeasurementResult"/> from a SharedSizeGroup.
+        /// Does nothing for empty SharedSizeGroups.
+        /// </summary>
+        /// <param name="scopeName">The name (can be null or empty) of the group to remove the <paramref name="result"/> from.</param>
+        /// <param name="result">The <see cref="MeasurementResult"/> to remove from a scope.</param>
+        private void RemoveFromGroup(string scopeName, MeasurementResult result)
+        {
+            if (string.IsNullOrEmpty(scopeName))
+                return;
+
+            if (!_groups.TryGetValue(scopeName, out var group))
+                throw new AvaloniaInternalException($"SharedSizeScopeHost: The scope {scopeName} wasn't found in the shared size scope");
+
+            group.Remove(result);
+            if (!group.Results.Any())
+                _groups.Remove(scopeName);
+        }
+    }
+}
diff --git a/src/Avalonia.Controls/Window.cs b/src/Avalonia.Controls/Window.cs
index 39b4f05545..46916efc1d 100644
--- a/src/Avalonia.Controls/Window.cs
+++ b/src/Avalonia.Controls/Window.cs
@@ -397,11 +397,23 @@ namespace Avalonia.Controls
         /// <returns>
         /// A task that can be used to track the lifetime of the dialog.
         /// </returns>
-        public Task ShowDialog()
+        public Task ShowDialog(Window parent)
         {
-            return ShowDialog<object>();
+            return ShowDialog<object>(parent);
         }
 
+
+        /// <summary>
+        /// Shows the window as a dialog.
+        /// </summary>
+        /// <typeparam name="TResult">
+        /// The type of the result produced by the dialog.
+        /// </typeparam>
+        /// <returns>.
+        /// A task that can be used to retrieve the result of the dialog when it closes.
+        /// </returns>
+        public Task<TResult> ShowDialog<TResult>(Window parent) => ShowDialog<TResult>(parent.PlatformImpl);
+        
         /// <summary>
         /// Shows the window as a dialog.
         /// </summary>
@@ -411,8 +423,10 @@ namespace Avalonia.Controls
         /// <returns>.
         /// A task that can be used to retrieve the result of the dialog when it closes.
         /// </returns>
-        public Task<TResult> ShowDialog<TResult>()
+        public Task<TResult> ShowDialog<TResult>(IWindowImpl parent)
         {
+            if(parent == null)
+                throw new ArgumentNullException(nameof(parent));
             if (IsVisible)
             {
                 throw new InvalidOperationException("The window is already being shown.");
@@ -427,24 +441,18 @@ namespace Avalonia.Controls
 
             using (BeginAutoSizing())
             {
-                var affectedWindows = Application.Current.Windows.Where(w => w.IsEnabled && w != this).ToList();
-                var activated = affectedWindows.Where(w => w.IsActive).FirstOrDefault();
-                SetIsEnabled(affectedWindows, false);
 
-                var modal = PlatformImpl?.ShowDialog();
+                PlatformImpl?.ShowDialog(parent);
                 var result = new TaskCompletionSource<TResult>();
 
                 Renderer?.Start();
-
                 Observable.FromEventPattern<EventHandler, EventArgs>(
                     x => this.Closed += x,
                     x => this.Closed -= x)
                     .Take(1)
                     .Subscribe(_ =>
                     {
-                        modal?.Dispose();
-                        SetIsEnabled(affectedWindows, true);
-                        activated?.Activate();
+                        parent.Activate();
                         result.SetResult((TResult)(_dialogResult ?? default(TResult)));
                     });
 
@@ -452,14 +460,6 @@ namespace Avalonia.Controls
             }
         }
 
-        void SetIsEnabled(IEnumerable<Window> windows, bool isEnabled)
-        {
-            foreach (var window in windows)
-            {
-                window.IsEnabled = isEnabled;
-            }
-        }
-
         void SetWindowStartupLocation()
         {
             if (WindowStartupLocation == WindowStartupLocation.CenterScreen)
diff --git a/src/Avalonia.DesignerSupport/Remote/PreviewerWindowImpl.cs b/src/Avalonia.DesignerSupport/Remote/PreviewerWindowImpl.cs
index ed2c55895c..cff59f2f8b 100644
--- a/src/Avalonia.DesignerSupport/Remote/PreviewerWindowImpl.cs
+++ b/src/Avalonia.DesignerSupport/Remote/PreviewerWindowImpl.cs
@@ -86,9 +86,8 @@ namespace Avalonia.DesignerSupport.Remote
         {
         }
 
-        public IDisposable ShowDialog()
+        public void ShowDialog(IWindowImpl parent)
         {
-            return Disposable.Empty;
         }
 
         public void SetSystemDecorations(bool enabled)
@@ -111,4 +110,4 @@ namespace Avalonia.DesignerSupport.Remote
         {
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Avalonia.DesignerSupport/Remote/Stubs.cs b/src/Avalonia.DesignerSupport/Remote/Stubs.cs
index 3a97b0d799..8f5b97af41 100644
--- a/src/Avalonia.DesignerSupport/Remote/Stubs.cs
+++ b/src/Avalonia.DesignerSupport/Remote/Stubs.cs
@@ -87,7 +87,9 @@ namespace Avalonia.DesignerSupport.Remote
         {
         }
 
-        public IDisposable ShowDialog() => Disposable.Empty;
+        public void ShowDialog(IWindowImpl parent)
+        {
+        }
 
         public void SetSystemDecorations(bool enabled)
         {
@@ -157,4 +159,4 @@ namespace Avalonia.DesignerSupport.Remote
         public Screen[] AllScreens { get; } =
             {new Screen(new Rect(0, 0, 4000, 4000), new Rect(0, 0, 4000, 4000), true)};
     }
-}
\ No newline at end of file
+}
diff --git a/src/Avalonia.Input/InputExtensions.cs b/src/Avalonia.Input/InputExtensions.cs
index a861bae528..f184e41998 100644
--- a/src/Avalonia.Input/InputExtensions.cs
+++ b/src/Avalonia.Input/InputExtensions.cs
@@ -45,7 +45,8 @@ namespace Avalonia.Input
             return element != null &&
                    element.IsVisible &&
                    element.IsHitTestVisible &&
-                   element.IsEnabledCore;
+                   element.IsEnabledCore &&
+                   element.IsAttachedToVisualTree;
         }
     }
 }
diff --git a/src/Avalonia.Layout/Properties/AssemblyInfo.cs b/src/Avalonia.Layout/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000000..70fc1e9330
--- /dev/null
+++ b/src/Avalonia.Layout/Properties/AssemblyInfo.cs
@@ -0,0 +1,6 @@
+// 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.Metadata;
+
+[assembly: XmlnsDefinition("https://github.com/avaloniaui", "Avalonia.Layout")]
diff --git a/src/Avalonia.Native/AvaloniaNativeDeferredRendererLock.cs b/src/Avalonia.Native/AvaloniaNativeDeferredRendererLock.cs
new file mode 100644
index 0000000000..6dd5337b27
--- /dev/null
+++ b/src/Avalonia.Native/AvaloniaNativeDeferredRendererLock.cs
@@ -0,0 +1,23 @@
+using System;
+using System.Reactive.Disposables;
+using Avalonia.Native.Interop;
+using Avalonia.Rendering;
+
+namespace Avalonia.Native
+{
+    public class AvaloniaNativeDeferredRendererLock : IDeferredRendererLock
+    {
+        private readonly IAvnWindowBase _window;
+
+        public AvaloniaNativeDeferredRendererLock(IAvnWindowBase window)
+        {
+            _window = window;
+        }
+        public IDisposable TryLock()
+        {
+            if (_window.TryLock())
+                return Disposable.Create(() => _window.Unlock());
+            return null;
+        }
+    }
+}
diff --git a/src/Avalonia.Native/ClipboardImpl.cs b/src/Avalonia.Native/ClipboardImpl.cs
index d54bc95fbb..c756a6d9c2 100644
--- a/src/Avalonia.Native/ClipboardImpl.cs
+++ b/src/Avalonia.Native/ClipboardImpl.cs
@@ -5,6 +5,7 @@ using System.Threading.Tasks;
 using System.Runtime.InteropServices;
 using Avalonia.Input.Platform;
 using Avalonia.Native.Interop;
+using Avalonia.Platform.Interop;
 
 namespace Avalonia.Native
 {
@@ -24,12 +25,14 @@ namespace Avalonia.Native
             return Task.CompletedTask;
         }
 
-        public Task<string> GetTextAsync()
+        public unsafe Task<string> GetTextAsync()
         {
-            var outPtr = _native.GetText();
-            var text = Marshal.PtrToStringAnsi(outPtr);
+            using (var text = _native.GetText())
+            {
+                var result = System.Text.Encoding.UTF8.GetString((byte*)text.Pointer(), text.Length());
 
-            return Task.FromResult(text);
+                return Task.FromResult(result);
+            }
         }
 
         public Task SetTextAsync(string text)
@@ -38,7 +41,10 @@ namespace Avalonia.Native
 
             if (text != null)
             {
-                _native.SetText(text);
+                using (var buffer = new Utf8Buffer(text))
+                {
+                    _native.SetText(buffer.DangerousGetHandle());
+                }
             }
 
             return Task.CompletedTask;
diff --git a/src/Avalonia.Native/DeferredRendererProxy.cs b/src/Avalonia.Native/DeferredRendererProxy.cs
deleted file mode 100644
index 126a395f73..0000000000
--- a/src/Avalonia.Native/DeferredRendererProxy.cs
+++ /dev/null
@@ -1,108 +0,0 @@
-// 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.Native.Interop;
-using Avalonia.Rendering;
-using Avalonia.VisualTree;
-
-namespace Avalonia.Native
-{
-    public class DeferredRendererProxy : IRenderer, IRenderLoopTask, IRenderLoop
-    {
-        public DeferredRendererProxy(IRenderRoot root, IAvnWindowBase window)
-        {
-            if (window != null)
-            {
-                _useLock = true;
-                window.AddRef();
-_window = new IAvnWindowBase(window.NativePointer);
-            }
-            _renderer = new DeferredRenderer(root, this);
-            _rendererTask = (IRenderLoopTask)_renderer;
-        }
-
-        void IRenderLoop.Add(IRenderLoopTask i)
-        {
-            AvaloniaLocator.Current.GetService<IRenderLoop>().Add(this);
-        }
-
-        void IRenderLoop.Remove(IRenderLoopTask i)
-        {
-            AvaloniaLocator.Current.GetService<IRenderLoop>().Remove(this);
-        }
-
-        private DeferredRenderer _renderer;
-        private IRenderLoopTask _rendererTask;
-        private IAvnWindowBase _window;
-        private bool _useLock;
-
-        public bool DrawFps{
-            get => _renderer.DrawFps;
-            set => _renderer.DrawFps = value;
-        }
-        public bool DrawDirtyRects 
-        {
-            get => _renderer.DrawDirtyRects;
-            set => _renderer.DrawDirtyRects = value;
-        }
-
-        public bool NeedsUpdate => _rendererTask.NeedsUpdate;
-
-        public void AddDirty(IVisual visual) => _renderer.AddDirty(visual);
-
-        public void Dispose()
-        {
-            _renderer.Dispose();
-            _window?.Dispose();
-            _window = null;
-        }
-        public IEnumerable<IVisual> HitTest(Point p, IVisual root, Func<IVisual, bool> filter)
-        {
-            return _renderer.HitTest(p, root, filter);
-        }
-
-        public void Paint(Rect rect)
-        {
-            if (NeedsUpdate)
-            {
-                Update(TimeSpan.FromMilliseconds(Environment.TickCount));
-            }
-
-            Render();
-        }
-
-        public void Resized(Size size) => _renderer.Resized(size);
-
-        public void Start() => _renderer.Start();
-
-        public void Stop() => _renderer.Stop();
-
-        public void Update(TimeSpan time)
-        {
-            _rendererTask.Update(time);
-        }
-
-        public void Render()
-        {
-            if(_useLock)
-            {
-                _rendererTask.Render();
-                return;
-            }
-            if (_window == null)
-                return;
-            if (!_window.TryLock())
-                return;
-            try
-            {
-                _rendererTask.Render();
-            }
-            finally
-            {
-                _window.Unlock();
-            }
-        }
-    }
-}
diff --git a/src/Avalonia.Native/GlPlatformFeature.cs b/src/Avalonia.Native/GlPlatformFeature.cs
index 97785e4a81..e39680bdee 100644
--- a/src/Avalonia.Native/GlPlatformFeature.cs
+++ b/src/Avalonia.Native/GlPlatformFeature.cs
@@ -58,10 +58,8 @@ namespace Avalonia.Native
 
         public IGlDisplay Display { get; }
 
-        public void MakeCurrent(IGlSurface surface)
+        public void MakeCurrent()
         {
-            if (surface != null)
-                throw new ArgumentException(nameof(surface));
             Context.MakeCurrent();
         }
     }
diff --git a/src/Avalonia.Native/WindowImpl.cs b/src/Avalonia.Native/WindowImpl.cs
index 5d30408e52..4a3a23b4c8 100644
--- a/src/Avalonia.Native/WindowImpl.cs
+++ b/src/Avalonia.Native/WindowImpl.cs
@@ -5,6 +5,7 @@ using System;
 using Avalonia.Controls;
 using Avalonia.Native.Interop;
 using Avalonia.Platform;
+using Avalonia.Platform.Interop;
 
 namespace Avalonia.Native
 {
@@ -46,9 +47,9 @@ namespace Avalonia.Native
 
         public IAvnWindow Native => _native;
 
-        public IDisposable ShowDialog()
+        public void ShowDialog(IWindowImpl window)
         {
-            return _native.ShowDialog();
+            _native.ShowDialog(((WindowImpl)window).Native);
         }
 
         public void CanResize(bool value)
@@ -68,7 +69,10 @@ namespace Avalonia.Native
 
         public void SetTitle(string title)
         {
-            _native.SetTitle(title);
+            using (var buffer = new Utf8Buffer(title))
+            {
+                _native.SetTitle(buffer.DangerousGetHandle());
+            }
         }
 
         public WindowState WindowState
diff --git a/src/Avalonia.Native/WindowImplBase.cs b/src/Avalonia.Native/WindowImplBase.cs
index aaaba44fff..629c91a2e8 100644
--- a/src/Avalonia.Native/WindowImplBase.cs
+++ b/src/Avalonia.Native/WindowImplBase.cs
@@ -186,10 +186,6 @@ namespace Avalonia.Native
 
             void IAvnWindowBaseEvents.RunRenderPriorityJobs()
             {
-                if (_parent._deferredRendering
-                    && _parent._lastRenderedLogicalSize != _parent.ClientSize)
-                    // Hack to trigger Paint event on the renderer
-                    _parent.Paint?.Invoke(new Rect());
                 Dispatcher.UIThread.RunJobs(DispatcherPriority.Render);
             }
         }
@@ -245,7 +241,9 @@ namespace Avalonia.Native
         public IRenderer CreateRenderer(IRenderRoot root)
         {
             if (_deferredRendering)
-                return new DeferredRendererProxy(root, _gpu ? _native : null);
+                return new DeferredRenderer(root, AvaloniaLocator.Current.GetService<IRenderLoop>(),
+                    rendererLock:
+                    _gpu ? new AvaloniaNativeDeferredRendererLock(_native) : null);
             return new ImmediateRenderer(root);
         }
 
diff --git a/src/Avalonia.OpenGL/EglContext.cs b/src/Avalonia.OpenGL/EglContext.cs
new file mode 100644
index 0000000000..27b1abe411
--- /dev/null
+++ b/src/Avalonia.OpenGL/EglContext.cs
@@ -0,0 +1,44 @@
+using System;
+using System.Reactive.Disposables;
+using System.Threading;
+
+namespace Avalonia.OpenGL
+{
+    public class EglContext : IGlContext
+    {
+        private readonly EglDisplay _disp;
+        private readonly EglInterface _egl;
+        private readonly object _lock = new object();
+
+        public EglContext(EglDisplay display, EglInterface egl, IntPtr ctx, IntPtr offscreenSurface)
+        {
+            _disp = display;
+            _egl = egl;
+            Context = ctx;
+            OffscreenSurface = offscreenSurface;
+        }
+
+        public IntPtr Context { get; }
+        public IntPtr OffscreenSurface { get; }
+        public IGlDisplay Display => _disp;
+
+        public IDisposable Lock()
+        {
+            Monitor.Enter(_lock);
+            return Disposable.Create(() => Monitor.Exit(_lock));
+        }
+
+        public void MakeCurrent()
+        {
+            if (!_egl.MakeCurrent(_disp.Handle, IntPtr.Zero, IntPtr.Zero, Context))
+                throw new OpenGlException("eglMakeCurrent failed");
+        }
+        
+        public void MakeCurrent(EglSurface surface)
+        {
+            var surf = ((EglSurface)surface)?.DangerousGetHandle() ?? OffscreenSurface;
+            if (!_egl.MakeCurrent(_disp.Handle, surf, surf, Context))
+                throw new OpenGlException("eglMakeCurrent failed");
+        }
+    }
+}
diff --git a/src/Avalonia.OpenGL/EglDisplay.cs b/src/Avalonia.OpenGL/EglDisplay.cs
index ea0a9bf087..90a70adcb7 100644
--- a/src/Avalonia.OpenGL/EglDisplay.cs
+++ b/src/Avalonia.OpenGL/EglDisplay.cs
@@ -12,7 +12,8 @@ namespace Avalonia.OpenGL
         private readonly IntPtr _display;
         private readonly IntPtr _config;
         private readonly int[] _contextAttributes;
-        
+
+        public IntPtr Handle => _display;
         public EglDisplay(EglInterface egl)
         {
             _egl = egl;  
@@ -121,7 +122,7 @@ namespace Avalonia.OpenGL
             });
             if (surf == IntPtr.Zero)
                 throw new OpenGlException("eglCreatePbufferSurface failed");
-            var rv = new EglContext(this, ctx, surf);
+            var rv = new EglContext(this, _egl, ctx, surf);
             rv.MakeCurrent(null);
             return rv;
         }
@@ -132,12 +133,12 @@ namespace Avalonia.OpenGL
                 throw new OpenGlException("eglMakeCurrent failed");
         }
 
-        public IGlSurface CreateWindowSurface(IntPtr window)
+        public EglSurface CreateWindowSurface(IntPtr window)
         {
             var s = _egl.CreateWindowSurface(_display, _config, window, new[] {EGL_NONE, EGL_NONE});
             if (s == IntPtr.Zero)
                 throw new OpenGlException("eglCreateWindowSurface failed");
-            return new EglSurface(this, s);
+            return new EglSurface(this, _egl, s);
         }
 
         public int SampleCount
@@ -157,49 +158,5 @@ namespace Avalonia.OpenGL
                 return rv;
             }
         }
-
-        class EglSurface : SafeHandle, IGlSurface
-        {
-            private readonly EglDisplay _display;
-
-            public EglSurface(EglDisplay display, IntPtr surface)  : base(surface, true)
-            {
-                _display = display;
-            }
-
-            protected override bool ReleaseHandle()
-            {
-                _display._egl.DestroySurface(_display._display, handle);
-                return true;
-            }
-
-            public override bool IsInvalid => handle == IntPtr.Zero;
-
-            public IGlDisplay Display => _display;
-            public void SwapBuffers() => _display._egl.SwapBuffers(_display._display, handle);
-        }
-        
-        class EglContext : IGlContext
-        {
-            private readonly EglDisplay _disp;
-
-            public EglContext(EglDisplay display, IntPtr ctx, IntPtr offscreenSurface)
-            {
-                _disp = display;
-                Context = ctx;
-                OffscreenSurface = offscreenSurface;
-            }
-
-            public IntPtr Context { get; }
-            public IntPtr OffscreenSurface { get; }
-            public IGlDisplay Display => _disp;
-
-            public void MakeCurrent(IGlSurface surface)
-            {
-                var surf = ((EglSurface)surface)?.DangerousGetHandle() ?? OffscreenSurface;
-                if (!_disp._egl.MakeCurrent(_disp._display, surf, surf, Context))
-                    throw new OpenGlException("eglMakeCurrent failed");
-            }
-        }
     }
 }
diff --git a/src/Avalonia.OpenGL/EglGlPlatformFeature.cs b/src/Avalonia.OpenGL/EglGlPlatformFeature.cs
index 535e32924e..86411b89da 100644
--- a/src/Avalonia.OpenGL/EglGlPlatformFeature.cs
+++ b/src/Avalonia.OpenGL/EglGlPlatformFeature.cs
@@ -7,7 +7,7 @@ namespace Avalonia.OpenGL
     {
         public IGlDisplay Display { get; set; }
         public IGlContext ImmediateContext { get; set; }
-        public IGlContext DeferredContext { get; set; }
+        public EglContext DeferredContext { get; set; }
 
         public static void TryInitialize()
         {
@@ -26,7 +26,7 @@ namespace Avalonia.OpenGL
                 {
                     Display = disp,
                     ImmediateContext = ctx,
-                    DeferredContext = disp.CreateContext(ctx)
+                    DeferredContext = (EglContext)disp.CreateContext(ctx)
                 };
             }
             catch(Exception e)
diff --git a/src/Avalonia.OpenGL/EglGlPlatformSurface.cs b/src/Avalonia.OpenGL/EglGlPlatformSurface.cs
index c99c869c4f..f5dd413b0f 100644
--- a/src/Avalonia.OpenGL/EglGlPlatformSurface.cs
+++ b/src/Avalonia.OpenGL/EglGlPlatformSurface.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Threading;
 
 namespace Avalonia.OpenGL
 {
@@ -12,10 +13,10 @@ namespace Avalonia.OpenGL
         }
 
         private readonly EglDisplay _display;
-        private readonly IGlContext _context;
+        private readonly EglContext _context;
         private readonly IEglWindowGlPlatformSurfaceInfo _info;
         
-        public EglGlPlatformSurface(EglDisplay display, IGlContext context, IEglWindowGlPlatformSurfaceInfo info)
+        public EglGlPlatformSurface(EglDisplay display, EglContext context, IEglWindowGlPlatformSurfaceInfo info)
         {
             _display = display;
             _context = context;
@@ -30,11 +31,11 @@ namespace Avalonia.OpenGL
 
         class RenderTarget : IGlPlatformSurfaceRenderTarget
         {
-            private readonly IGlContext _context;
-            private readonly IGlSurface _glSurface;
+            private readonly EglContext _context;
+            private readonly EglSurface _glSurface;
             private readonly IEglWindowGlPlatformSurfaceInfo _info;
 
-            public RenderTarget(IGlContext context, IGlSurface glSurface, IEglWindowGlPlatformSurfaceInfo info)
+            public RenderTarget(EglContext context, EglSurface glSurface, IEglWindowGlPlatformSurfaceInfo info)
             {
                 _context = context;
                 _glSurface = glSurface;
@@ -45,21 +46,33 @@ namespace Avalonia.OpenGL
 
             public IGlPlatformSurfaceRenderingSession BeginDraw()
             {
-                _context.MakeCurrent(_glSurface);
-                return new Session(_context, _glSurface, _info);
+                var l = _context.Lock();
+                try
+                {
+                    _context.MakeCurrent(_glSurface);
+                    return new Session(_context, _glSurface, _info, l);
+                }
+                catch
+                {
+                    l.Dispose();
+                    throw;
+                }
             }
             
             class Session : IGlPlatformSurfaceRenderingSession
             {
                 private readonly IGlContext _context;
-                private readonly IGlSurface _glSurface;
+                private readonly EglSurface _glSurface;
                 private readonly IEglWindowGlPlatformSurfaceInfo _info;
+                private IDisposable _lock;
 
-                public Session(IGlContext context, IGlSurface glSurface, IEglWindowGlPlatformSurfaceInfo info)
+                public Session(IGlContext context, EglSurface glSurface, IEglWindowGlPlatformSurfaceInfo info,
+                    IDisposable @lock)
                 {
                     _context = context;
                     _glSurface = glSurface;
                     _info = info;
+                    _lock = @lock;
                 }
 
                 public void Dispose()
@@ -67,6 +80,7 @@ namespace Avalonia.OpenGL
                     _context.Display.GlInterface.Flush();
                     _glSurface.SwapBuffers();
                     _context.Display.ClearContext();
+                    _lock.Dispose();
                 }
 
                 public IGlDisplay Display => _context.Display;
diff --git a/src/Avalonia.OpenGL/EglSurface.cs b/src/Avalonia.OpenGL/EglSurface.cs
new file mode 100644
index 0000000000..90bb1e36d0
--- /dev/null
+++ b/src/Avalonia.OpenGL/EglSurface.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace Avalonia.OpenGL
+{
+    public class EglSurface : SafeHandle
+    {
+        private readonly EglDisplay _display;
+        private readonly EglInterface _egl;
+
+        public EglSurface(EglDisplay display, EglInterface egl, IntPtr surface)  : base(surface, true)
+        {
+            _display = display;
+            _egl = egl;
+        }
+
+        protected override bool ReleaseHandle()
+        {
+            _egl.DestroySurface(_display.Handle, handle);
+            return true;
+        }
+
+        public override bool IsInvalid => handle == IntPtr.Zero;
+
+        public IGlDisplay Display => _display;
+        public void SwapBuffers() => _egl.SwapBuffers(_display.Handle, handle);
+    }
+}
\ No newline at end of file
diff --git a/src/Avalonia.OpenGL/IGlContext.cs b/src/Avalonia.OpenGL/IGlContext.cs
index 954567fe2e..04aa1b98e4 100644
--- a/src/Avalonia.OpenGL/IGlContext.cs
+++ b/src/Avalonia.OpenGL/IGlContext.cs
@@ -3,6 +3,6 @@ namespace Avalonia.OpenGL
     public interface IGlContext
     {
         IGlDisplay Display { get; }
-        void MakeCurrent(IGlSurface surface);
+        void MakeCurrent();
     }
-}
\ No newline at end of file
+}
diff --git a/src/Avalonia.OpenGL/IGlSurface.cs b/src/Avalonia.OpenGL/IGlSurface.cs
deleted file mode 100644
index 499d0a3c90..0000000000
--- a/src/Avalonia.OpenGL/IGlSurface.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-using System;
-
-namespace Avalonia.OpenGL
-{
-    public interface IGlSurface : IDisposable
-    {
-        IGlDisplay Display { get; }
-        void SwapBuffers();
-    }
-}
\ No newline at end of file
diff --git a/src/Avalonia.Themes.Default/ButtonSpinner.xaml b/src/Avalonia.Themes.Default/ButtonSpinner.xaml
index 8284b4eddf..5417d5fb0b 100644
--- a/src/Avalonia.Themes.Default/ButtonSpinner.xaml
+++ b/src/Avalonia.Themes.Default/ButtonSpinner.xaml
@@ -1,17 +1,17 @@
 <Styles xmlns="https://github.com/avaloniaui">
   <Style Selector="ButtonSpinner">
-    <Setter Property="BorderBrush" Value="{DynamicResource ThemeBorderLowBrush}"/>
+    <Setter Property="BorderBrush" Value="{DynamicResource ThemeBorderMidBrush}"/>
     <Setter Property="BorderThickness" Value="{DynamicResource ThemeBorderThickness}"/>
     <Setter Property="HorizontalContentAlignment" Value="Stretch"/>
     <Setter Property="VerticalContentAlignment" Value="Center"/>
   </Style>
   <Style Selector="ButtonSpinner /template/ RepeatButton">
-    <Setter Property="RepeatButton.Background" Value="Transparent"/>
-    <Setter Property="RepeatButton.BorderBrush" Value="Transparent"/>
+    <Setter Property="Background" Value="Transparent"/>
+    <Setter Property="BorderBrush" Value="Transparent"/>
   </Style>
   <Style Selector="ButtonSpinner /template/ RepeatButton:pointerover">
-    <Setter Property="RepeatButton.Background" Value="{DynamicResource ThemeControlMidBrush}"/>
-    <Setter Property="RepeatButton.BorderBrush" Value="{DynamicResource ThemeBorderMidBrush}"/>
+    <Setter Property="Background" Value="{DynamicResource ThemeControlMidBrush}"/>
+    <Setter Property="BorderBrush" Value="{DynamicResource ThemeBorderMidBrush}"/>
   </Style>
   <Style Selector="ButtonSpinner /template/ RepeatButton#PART_IncreaseButton">
     <Setter Property="Content">
@@ -42,7 +42,8 @@
   <Style Selector="ButtonSpinner:right">
     <Setter Property="Template">
       <ControlTemplate>
-        <Border Background="{TemplateBinding Background}"
+        <Border Name="border"
+                Background="{TemplateBinding Background}"
                 BorderBrush="{TemplateBinding BorderBrush}"
                 BorderThickness="{TemplateBinding BorderThickness}"
                 Margin="{TemplateBinding Padding}"
@@ -67,7 +68,8 @@
   <Style Selector="ButtonSpinner:left">
     <Setter Property="Template">
       <ControlTemplate>
-        <Border Background="{TemplateBinding Background}"
+        <Border Name="border"
+                Background="{TemplateBinding Background}"
                 BorderBrush="{TemplateBinding BorderBrush}"
                 BorderThickness="{TemplateBinding BorderThickness}"
                 Margin="{TemplateBinding Padding}"
@@ -89,4 +91,13 @@
       </ControlTemplate>
     </Setter>
   </Style>
-</Styles>
\ No newline at end of file
+  <Style Selector="ButtonSpinner:pointerover /template/ Border#border">
+    <Setter Property="BorderBrush" Value="{DynamicResource ThemeBorderHighBrush}"/>
+  </Style>
+  <Style Selector="ButtonSpinner:focus /template/ Border#border">
+    <Setter Property="BorderBrush" Value="{DynamicResource ThemeBorderHighBrush}"/>
+  </Style>
+  <Style Selector="ButtonSpinner:error /template/ Border#border">
+    <Setter Property="BorderBrush" Value="{DynamicResource ErrorBrush}"/>
+  </Style>
+</Styles>
diff --git a/src/Avalonia.Themes.Default/NumericUpDown.xaml b/src/Avalonia.Themes.Default/NumericUpDown.xaml
index 8c5594cee8..24cbb62908 100644
--- a/src/Avalonia.Themes.Default/NumericUpDown.xaml
+++ b/src/Avalonia.Themes.Default/NumericUpDown.xaml
@@ -1,10 +1,10 @@
 <Styles xmlns="https://github.com/avaloniaui">
   <Style Selector="NumericUpDown">
-    <Setter Property="TemplatedControl.BorderBrush" Value="{DynamicResource ThemeBorderLowBrush}"/>
-    <Setter Property="TemplatedControl.BorderThickness" Value="{DynamicResource ThemeBorderThickness}"/>
-    <Setter Property="TemplatedControl.Background" Value="{DynamicResource ThemeBackgroundBrush}" />
-    <Setter Property="TemplatedControl.Foreground" Value="{DynamicResource ThemeForegroundBrush}" />
-    <Setter Property="TemplatedControl.Template">
+    <Setter Property="Background" Value="{DynamicResource ThemeBackgroundBrush}" />
+    <Setter Property="BorderBrush" Value="{DynamicResource ThemeBorderMidBrush}"/>
+    <Setter Property="BorderThickness" Value="{DynamicResource ThemeBorderThickness}"/>
+    <Setter Property="Padding" Value="4"/>
+    <Setter Property="Template">
       <ControlTemplate>
         <ButtonSpinner Name="PART_Spinner"
                        Background="{TemplateBinding Background}"
@@ -17,20 +17,13 @@
                        ButtonSpinnerLocation="{TemplateBinding ButtonSpinnerLocation}">
           <TextBox Name="PART_TextBox"
                    BorderThickness="0"
-                   Background="Transparent"
-                   ContextMenu="{TemplateBinding ContextMenu}"
-                   FontFamily="{TemplateBinding FontFamily}"
-                   FontSize="{TemplateBinding FontSize}"
-                   FontStyle="{TemplateBinding FontStyle}"
-                   FontWeight="{TemplateBinding FontWeight}"
-                   Foreground="{TemplateBinding Foreground}"
+                   Background="{TemplateBinding Background}" 
+                   BorderBrush="{TemplateBinding BorderBrush}"
+                   Padding="{TemplateBinding Padding}"
                    Watermark="{TemplateBinding Watermark}"
+                   DataValidationErrors.Errors="{TemplateBinding (DataValidationErrors.Errors)}"
                    IsReadOnly="{TemplateBinding IsReadOnly}"
                    Text="{TemplateBinding Text}"
-                   Padding="{TemplateBinding Padding}"
-                   TextAlignment="Left"
-                   Margin="1"
-                   MinWidth="20"
                    AcceptsReturn="False"
                    TextWrapping="NoWrap">
           </TextBox>
@@ -38,4 +31,8 @@
       </ControlTemplate>
     </Setter>
   </Style>
+  <Style Selector="NumericUpDown /template/ TextBox#PART_TextBox">
+    <Setter Property="Margin" Value="4"/>
+    <Setter Property="MinWidth" Value="20"/>
+  </Style>
 </Styles>
\ No newline at end of file
diff --git a/src/Avalonia.Themes.Default/TextBox.xaml b/src/Avalonia.Themes.Default/TextBox.xaml
index 53028f72a6..90100c2f2b 100644
--- a/src/Avalonia.Themes.Default/TextBox.xaml
+++ b/src/Avalonia.Themes.Default/TextBox.xaml
@@ -62,4 +62,7 @@
   <Style Selector="TextBox:error /template/ Border#border">
     <Setter Property="BorderBrush" Value="{DynamicResource ErrorBrush}"/>
   </Style>
-</Styles>
\ No newline at end of file
+  <Style Selector="TextBox">
+    <Setter Property="Cursor" Value="IBeam" />
+  </Style>
+</Styles>
diff --git a/src/Avalonia.Visuals/Rendering/DeferredRenderer.cs b/src/Avalonia.Visuals/Rendering/DeferredRenderer.cs
index 5a6f086f7e..a268eff78a 100644
--- a/src/Avalonia.Visuals/Rendering/DeferredRenderer.cs
+++ b/src/Avalonia.Visuals/Rendering/DeferredRenderer.cs
@@ -36,6 +36,7 @@ namespace Avalonia.Rendering
         private int _lastSceneId = -1;
         private DisplayDirtyRects _dirtyRectsDisplay = new DisplayDirtyRects();
         private IRef<IDrawOperation> _currentDraw;
+        private readonly IDeferredRendererLock _lock;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DeferredRenderer"/> class.
@@ -44,11 +45,13 @@ namespace Avalonia.Rendering
         /// <param name="renderLoop">The render loop.</param>
         /// <param name="sceneBuilder">The scene builder to use. Optional.</param>
         /// <param name="dispatcher">The dispatcher to use. Optional.</param>
+        /// <param name="rendererLock">Lock object used before trying to access render target</param>
         public DeferredRenderer(
             IRenderRoot root,
             IRenderLoop renderLoop,
             ISceneBuilder sceneBuilder = null,
-            IDispatcher dispatcher = null)
+            IDispatcher dispatcher = null,
+            IDeferredRendererLock rendererLock = null)
         {
             Contract.Requires<ArgumentNullException>(root != null);
 
@@ -57,6 +60,7 @@ namespace Avalonia.Rendering
             _sceneBuilder = sceneBuilder ?? new SceneBuilder();
             Layers = new RenderLayers();
             _renderLoop = renderLoop;
+            _lock = rendererLock ?? new ManagedDeferredRendererLock();
         }
 
         /// <summary>
@@ -137,6 +141,10 @@ namespace Avalonia.Rendering
         /// <inheritdoc/>
         public void Paint(Rect rect)
         {
+            var t = (IRenderLoopTask)this;
+            if(t.NeedsUpdate)
+                UpdateScene();
+            Render(true);
         }
 
         /// <inheritdoc/>
@@ -168,13 +176,7 @@ namespace Avalonia.Rendering
 
         void IRenderLoopTask.Update(TimeSpan time) => UpdateScene();
 
-        void IRenderLoopTask.Render()
-        {
-            using (var scene = _scene?.Clone())
-            {
-                Render(scene?.Item);
-            }
-        }
+        void IRenderLoopTask.Render() => Render(false);
 
         /// <inheritdoc/>
         Size IVisualBrushRenderer.GetRenderTargetSize(IVisualBrush brush)
@@ -195,9 +197,19 @@ namespace Avalonia.Rendering
 
         internal void UnitTestUpdateScene() => UpdateScene();
 
-        internal void UnitTestRender() => Render(_scene.Item);
+        internal void UnitTestRender() => Render(_scene.Item, false);
 
-        private void Render(Scene scene)
+        private void Render(bool forceComposite)
+        {
+            using (var l = _lock.TryLock())
+                if (l != null)
+                    using (var scene = _scene?.Clone())
+                    {
+                        Render(scene?.Item, forceComposite);
+                    }
+        }
+        
+        private void Render(Scene scene, bool forceComposite)
         {
             bool renderOverlay = DrawDirtyRects || DrawFps;
             bool composite = false;
@@ -241,7 +253,7 @@ namespace Avalonia.Rendering
                         RenderOverlay(scene, context);
                         RenderComposite(scene, context);
                     }
-                    else if (composite)
+                    else if (composite || forceComposite)
                     {
                         context = context ?? RenderTarget.CreateDrawingContext(this);
                         RenderComposite(scene, context);
@@ -415,7 +427,6 @@ namespace Avalonia.Rendering
                 oldScene?.Dispose();
 
                 _dirty.Clear();
-                (_root as IRenderRoot)?.Invalidate(new Rect(scene.Size));
             }
             else
             {
diff --git a/src/Avalonia.Visuals/Rendering/IDeferredRendererLock.cs b/src/Avalonia.Visuals/Rendering/IDeferredRendererLock.cs
new file mode 100644
index 0000000000..b2ed3afe6a
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/IDeferredRendererLock.cs
@@ -0,0 +1,9 @@
+using System;
+
+namespace Avalonia.Rendering
+{
+    public interface IDeferredRendererLock
+    {
+        IDisposable TryLock();
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/ManagedDeferredRendererLock.cs b/src/Avalonia.Visuals/Rendering/ManagedDeferredRendererLock.cs
new file mode 100644
index 0000000000..75d8f036d6
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/ManagedDeferredRendererLock.cs
@@ -0,0 +1,17 @@
+using System;
+using System.Reactive.Disposables;
+using System.Threading;
+
+namespace Avalonia.Rendering
+{
+    public class ManagedDeferredRendererLock : IDeferredRendererLock
+    {
+        private readonly object _lock = new object();
+        public IDisposable TryLock()
+        {
+            if (Monitor.TryEnter(_lock))
+                return Disposable.Create(() => Monitor.Exit(_lock));
+            return null;
+        }
+    }
+}
diff --git a/src/Gtk/Avalonia.Gtk3/Interop/Native.cs b/src/Gtk/Avalonia.Gtk3/Interop/Native.cs
index 98a73a98a9..bf973119a9 100644
--- a/src/Gtk/Avalonia.Gtk3/Interop/Native.cs
+++ b/src/Gtk/Avalonia.Gtk3/Interop/Native.cs
@@ -67,6 +67,9 @@ namespace Avalonia.Gtk3.Interop
 
             [UnmanagedFunctionPointer(CallingConvention.Cdecl), GtkImport(GtkDll.Gtk)]
             public delegate void gtk_window_set_modal(GtkWindow window, bool modal);
+            
+            [UnmanagedFunctionPointer(CallingConvention.Cdecl), GtkImport(GtkDll.Gtk)]
+            public delegate void gtk_window_set_transient_for(GtkWindow window, IntPtr parent);
 
             [UnmanagedFunctionPointer(CallingConvention.Cdecl)] //No manual import
             public delegate IntPtr gdk_get_native_handle(IntPtr gdkWindow);
@@ -408,6 +411,7 @@ namespace Avalonia.Gtk3.Interop
         public static D.gtk_window_new GtkWindowNew;
         public static D.gtk_window_set_icon GtkWindowSetIcon;
         public static D.gtk_window_set_modal GtkWindowSetModal;
+        public static D.gtk_window_set_transient_for GtkWindowSetTransientFor;
         public static D.gdk_set_allowed_backends GdkSetAllowedBackends;
         public static D.gtk_init GtkInit;
         public static D.gtk_window_present GtkWindowPresent;
diff --git a/src/Gtk/Avalonia.Gtk3/WindowBaseImpl.cs b/src/Gtk/Avalonia.Gtk3/WindowBaseImpl.cs
index 0273f6a7d8..6d4544bfbd 100644
--- a/src/Gtk/Avalonia.Gtk3/WindowBaseImpl.cs
+++ b/src/Gtk/Avalonia.Gtk3/WindowBaseImpl.cs
@@ -222,14 +222,14 @@ namespace Avalonia.Gtk3
         {
             var evnt = (GdkEventKey*) pev;
             _lastKbdEvent = evnt->time;
-            if (Native.GtkImContextFilterKeypress(_imContext, pev))
-                return true;
             var e = new RawKeyEventArgs(
                 Gtk3Platform.Keyboard,
                 evnt->time,
                 evnt->type == GdkEventType.KeyPress ? RawKeyEventType.KeyDown : RawKeyEventType.KeyUp,
                 Avalonia.Gtk.Common.KeyTransform.ConvertKey((GdkKey)evnt->keyval), GetModifierKeys((GdkModifierType)evnt->state));
             OnInput(e);
+            if (Native.GtkImContextFilterKeypress(_imContext, pev))
+                return true;
             return true;
         }
 
@@ -265,6 +265,8 @@ namespace Avalonia.Gtk3
                 Paint?.Invoke(new Rect(ClientSize));
                 CurrentCairoContext = IntPtr.Zero;
             }
+            else
+                Paint?.Invoke(new Rect(ClientSize));
             return true;
         }
 
@@ -422,7 +424,7 @@ namespace Avalonia.Gtk3
             Native.GdkWindowSetCursor(Native.GtkWidgetGetWindow(GtkWidget), cursor?.Handle ??  IntPtr.Zero);
         }
 
-        public void Show() => Native.GtkWindowPresent(GtkWidget);
+        public virtual void Show() => Native.GtkWindowPresent(GtkWidget);
 
         public void Hide() => Native.GtkWidgetHide(GtkWidget);
 
diff --git a/src/Gtk/Avalonia.Gtk3/WindowImpl.cs b/src/Gtk/Avalonia.Gtk3/WindowImpl.cs
index 34950ca8b8..1c8d800f2f 100644
--- a/src/Gtk/Avalonia.Gtk3/WindowImpl.cs
+++ b/src/Gtk/Avalonia.Gtk3/WindowImpl.cs
@@ -63,11 +63,18 @@ namespace Avalonia.Gtk3
 
         public Action<WindowState> WindowStateChanged { get; set; }
 
-        public IDisposable ShowDialog()
+        public void ShowDialog(IWindowImpl parent)
         {
             Native.GtkWindowSetModal(GtkWidget, true);
-            Show();
-            return new EmptyDisposable();
+            Native.GtkWindowSetTransientFor(GtkWidget, ((WindowImpl)parent).GtkWidget.DangerousGetHandle());
+            Native.GtkWindowPresent(GtkWidget);
+        }
+
+        public override void Show()
+        {
+            Native.GtkWindowSetModal(GtkWidget, false);
+            Native.GtkWindowSetTransientFor(GtkWidget, IntPtr.Zero);
+            Native.GtkWindowPresent(GtkWidget);
         }
 
         public void SetSystemDecorations(bool enabled) => Native.GtkWindowSetDecorated(GtkWidget, enabled);
diff --git a/src/Markup/Avalonia.Markup.Xaml/AvaloniaTypeConverters.cs b/src/Markup/Avalonia.Markup.Xaml/AvaloniaTypeConverters.cs
index 36c03be65a..13eb3f1ae3 100644
--- a/src/Markup/Avalonia.Markup.Xaml/AvaloniaTypeConverters.cs
+++ b/src/Markup/Avalonia.Markup.Xaml/AvaloniaTypeConverters.cs
@@ -1,6 +1,7 @@
 using System;
 using System.ComponentModel;
 using System.Collections.Generic;
+using System.Globalization;
 using Avalonia.Collections;
 using Avalonia.Controls;
 using Avalonia.Markup.Xaml.Converters;
@@ -36,6 +37,7 @@ namespace Avalonia.Markup.Xaml
             { typeof(Selector), typeof(SelectorTypeConverter) },
             { typeof(TimeSpan), typeof(TimeSpanTypeConverter) },
             { typeof(WindowIcon), typeof(IconTypeConverter) },
+            { typeof(CultureInfo), typeof(CultureInfoConverter)}
         };
 
         /// <summary>
diff --git a/src/Skia/Avalonia.Skia/PlatformRenderInterface.cs b/src/Skia/Avalonia.Skia/PlatformRenderInterface.cs
index dfd277ec86..9b10d74c64 100644
--- a/src/Skia/Avalonia.Skia/PlatformRenderInterface.cs
+++ b/src/Skia/Avalonia.Skia/PlatformRenderInterface.cs
@@ -28,7 +28,7 @@ namespace Avalonia.Skia
                 var iface = display.Type == GlDisplayType.OpenGL2
                     ? GRGlInterface.AssembleGlInterface((_, proc) => display.GlInterface.GetProcAddress(proc))
                     : GRGlInterface.AssembleGlesInterface((_, proc) => display.GlInterface.GetProcAddress(proc));
-                gl.ImmediateContext.MakeCurrent(null);
+                gl.ImmediateContext.MakeCurrent();
                 GrContext = GRContext.Create(GRBackend.OpenGL, iface);
             }
         }
diff --git a/src/Windows/Avalonia.Win32/Interop/UnmanagedMethods.cs b/src/Windows/Avalonia.Win32/Interop/UnmanagedMethods.cs
index f33b239dc6..9e8ff20e44 100644
--- a/src/Windows/Avalonia.Win32/Interop/UnmanagedMethods.cs
+++ b/src/Windows/Avalonia.Win32/Interop/UnmanagedMethods.cs
@@ -780,8 +780,8 @@ namespace Avalonia.Win32.Interop
         [DllImport("user32.dll", SetLastError = true, EntryPoint = "SetWindowLong")]
         private static extern uint SetWindowLong32b(IntPtr hWnd, int nIndex, uint value);
 
-        [DllImport("user32.dll", SetLastError = true)]
-        private static extern uint SetWindowLongPtr(IntPtr hWnd, int nIndex, uint value);
+        [DllImport("user32.dll", SetLastError = true, EntryPoint = "SetWindowLongPtr")]
+        private static extern IntPtr SetWindowLong64b(IntPtr hWnd, int nIndex, IntPtr value);
 
         public static uint SetWindowLong(IntPtr hWnd, int nIndex, uint value)
         {
@@ -791,7 +791,19 @@ namespace Avalonia.Win32.Interop
             }
             else
             {
-                return SetWindowLongPtr(hWnd, nIndex, value);
+                return (uint)SetWindowLong64b(hWnd, nIndex, new IntPtr((uint)value)).ToInt32();
+            }
+        }
+        
+        public static IntPtr SetWindowLongPtr(IntPtr hWnd, int nIndex, IntPtr handle)
+        {
+            if (IntPtr.Size == 4)
+            {
+                return new IntPtr(SetWindowLong32b(hWnd, nIndex, (uint)handle.ToInt32()));
+            }
+            else
+            {
+                return SetWindowLong64b(hWnd, nIndex, handle);
             }
         }
 
diff --git a/src/Windows/Avalonia.Win32/Win32Platform.cs b/src/Windows/Avalonia.Win32/Win32Platform.cs
index 103ca57cdb..cf7ebeed92 100644
--- a/src/Windows/Avalonia.Win32/Win32Platform.cs
+++ b/src/Windows/Avalonia.Win32/Win32Platform.cs
@@ -27,11 +27,11 @@ namespace Avalonia
     {
         public static T UseWin32<T>(
             this T builder,
-            bool deferredRendering = true) 
+            bool deferredRendering = true, bool allowEgl = false) 
                 where T : AppBuilderBase<T>, new()
         {
             return builder.UseWindowingSubsystem(
-                () => Win32.Win32Platform.Initialize(deferredRendering),
+                () => Win32.Win32Platform.Initialize(deferredRendering, allowEgl),
                 "Win32");
         }
     }
@@ -66,7 +66,7 @@ namespace Avalonia.Win32
             Initialize(true);
         }
 
-        public static void Initialize(bool deferredRendering = true)
+        public static void Initialize(bool deferredRendering = true, bool allowEgl = false)
         {
             AvaloniaLocator.CurrentMutable
                 .Bind<IClipboard>().ToSingleton<ClipboardImpl>()
@@ -80,7 +80,8 @@ namespace Avalonia.Win32
                 .Bind<IWindowingPlatform>().ToConstant(s_instance)
                 .Bind<PlatformHotkeyConfiguration>().ToSingleton<PlatformHotkeyConfiguration>()
                 .Bind<IPlatformIconLoader>().ToConstant(s_instance);
-            Win32GlManager.Initialize();
+            if (allowEgl)
+                Win32GlManager.Initialize();
             UseDeferredRendering = deferredRendering;
             _uiThread = Thread.CurrentThread;
 
diff --git a/src/Windows/Avalonia.Win32/WindowImpl.cs b/src/Windows/Avalonia.Win32/WindowImpl.cs
index 21986bd2ba..4c08e985cd 100644
--- a/src/Windows/Avalonia.Win32/WindowImpl.cs
+++ b/src/Windows/Avalonia.Win32/WindowImpl.cs
@@ -42,6 +42,8 @@ namespace Avalonia.Win32
         private OleDropTarget _dropTarget;
         private Size _minSize;
         private Size _maxSize;
+        private WindowImpl _parent;
+        private readonly List<WindowImpl> _disabledBy = new List<WindowImpl>();
 
 #if USE_MANAGED_DRAG
         private readonly ManagedWindowResizeDragHelper _managedDrag;
@@ -165,10 +167,10 @@ namespace Avalonia.Win32
             private set;
         }
 
-        public bool IsEnabled
+
+        void UpdateEnabled()
         {
-            get { return UnmanagedMethods.IsWindowEnabled(_hwnd); }
-            set { UnmanagedMethods.EnableWindow(_hwnd, value); }
+            EnableWindow(_hwnd, _disabledBy.Count == 0);
         }
 
         public Size MaxClientSize
@@ -248,6 +250,12 @@ namespace Avalonia.Win32
 
         public void Hide()
         {
+            if (_parent != null)
+            {
+                _parent._disabledBy.Remove(this);
+                _parent.UpdateEnabled();
+                _parent = null;
+            }
             UnmanagedMethods.ShowWindow(_hwnd, UnmanagedMethods.ShowWindowCommand.Hide);
         }
 
@@ -359,6 +367,7 @@ namespace Avalonia.Win32
 
         public virtual void Show()
         {
+            SetWindowLongPtr(_hwnd, (int)WindowLongParam.GWL_HWNDPARENT, IntPtr.Zero);
             ShowWindow(_showWindowState);
         }
 
@@ -412,11 +421,13 @@ namespace Avalonia.Win32
             }
         }
 
-        public virtual IDisposable ShowDialog()
+        public void ShowDialog(IWindowImpl parent)
         {
-            Show();
-
-            return Disposable.Empty;
+            _parent = (WindowImpl)parent;
+            _parent._disabledBy.Add(this);
+            _parent.UpdateEnabled();
+            SetWindowLongPtr(_hwnd, (int)WindowLongParam.GWL_HWNDPARENT, ((WindowImpl)parent)._hwnd);
+            ShowWindow(_showWindowState);
         }
 
         public void SetCursor(IPlatformHandle cursor)
@@ -490,6 +501,11 @@ namespace Avalonia.Win32
                     //Remove root reference to this class, so unmanaged delegate can be collected
                     s_instances.Remove(this);
                     Closed?.Invoke();
+                    if (_parent != null)
+                    {
+                        _parent._disabledBy.Remove(this);
+                        _parent.UpdateEnabled();
+                    }
                     //Free other resources
                     Dispose();
                     return IntPtr.Zero;
@@ -633,7 +649,6 @@ namespace Avalonia.Win32
 
                 case UnmanagedMethods.WindowsMessage.WM_PAINT:
                     UnmanagedMethods.PAINTSTRUCT ps;
-
                     if (UnmanagedMethods.BeginPaint(_hwnd, out ps) != IntPtr.Zero)
                     {
                         var f = Scaling;
diff --git a/tests/Avalonia.Controls.UnitTests/CursorFactoryMock.cs b/tests/Avalonia.Controls.UnitTests/CursorFactoryMock.cs
new file mode 100644
index 0000000000..da02cccdc5
--- /dev/null
+++ b/tests/Avalonia.Controls.UnitTests/CursorFactoryMock.cs
@@ -0,0 +1,14 @@
+using System;
+using Avalonia.Input;
+using Avalonia.Platform;
+
+namespace Avalonia.Controls.UnitTests
+{
+    public class CursorFactoryMock : IStandardCursorFactory
+    {
+        public IPlatformHandle GetCursor(StandardCursorType cursorType)
+        {
+            return new PlatformHandle(IntPtr.Zero, cursorType.ToString());
+        }
+    }
+}
diff --git a/tests/Avalonia.Controls.UnitTests/SharedSizeScopeTests.cs b/tests/Avalonia.Controls.UnitTests/SharedSizeScopeTests.cs
new file mode 100644
index 0000000000..715e9da880
--- /dev/null
+++ b/tests/Avalonia.Controls.UnitTests/SharedSizeScopeTests.cs
@@ -0,0 +1,284 @@
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia.Controls.Primitives;
+using Avalonia.Input;
+using Avalonia.Platform;
+using Avalonia.UnitTests;
+
+using Moq;
+
+using Xunit;
+
+namespace Avalonia.Controls.UnitTests
+{
+    public class SharedSizeScopeTests
+    {
+        public SharedSizeScopeTests()
+        {
+        }
+
+        [Fact]
+        public void All_Descendant_Grids_Are_Registered_When_Added_After_Setting_Scope()
+        {
+            var grids = new[] { new Grid(), new Grid(), new Grid() };
+            var scope = new Panel();
+            scope.Children.AddRange(grids);
+
+            var root = new TestRoot();
+            root.SetValue(Grid.IsSharedSizeScopeProperty, true);
+            root.Child = scope;
+
+            Assert.All(grids, g => Assert.True(g.HasSharedSizeScope()));
+        }
+
+        [Fact]
+        public void All_Descendant_Grids_Are_Registered_When_Setting_Scope()
+        {
+            var grids = new[] { new Grid(), new Grid(), new Grid() };
+            var scope = new Panel();
+            scope.Children.AddRange(grids);
+
+            var root = new TestRoot();
+            root.Child = scope;
+            root.SetValue(Grid.IsSharedSizeScopeProperty, true);
+
+            Assert.All(grids, g => Assert.True(g.HasSharedSizeScope()));
+        }
+
+        [Fact]
+        public void All_Descendant_Grids_Are_Unregistered_When_Resetting_Scope()
+        {
+            var grids = new[] { new Grid(), new Grid(), new Grid() };
+            var scope = new Panel();
+            scope.Children.AddRange(grids);
+
+            var root = new TestRoot();
+            root.SetValue(Grid.IsSharedSizeScopeProperty, true);
+            root.Child = scope;
+
+            Assert.All(grids, g => Assert.True(g.HasSharedSizeScope()));
+            root.SetValue(Grid.IsSharedSizeScopeProperty, false);
+            Assert.All(grids, g => Assert.False(g.HasSharedSizeScope()));
+            Assert.Equal(null, root.GetValue(Grid.s_sharedSizeScopeHostProperty));
+        }
+
+        [Fact]
+        public void Size_Is_Propagated_Between_Grids()
+        {
+            var grids = new[] { CreateGrid("A", null),CreateGrid(("A",new GridLength(30)), (null, new GridLength()))};
+            var scope = new Panel();
+            scope.Children.AddRange(grids);
+
+            var root = new TestRoot();
+            root.SetValue(Grid.IsSharedSizeScopeProperty, true);
+            root.Child = scope;
+
+            root.Measure(new Size(50, 50));
+            root.Arrange(new Rect(new Point(), new Point(50, 50)));
+            Assert.Equal(30, grids[0].ColumnDefinitions[0].ActualWidth);
+        }
+
+        [Fact]
+        public void Size_Propagation_Is_Constrained_To_Innermost_Scope()
+        {
+            var grids = new[] { CreateGrid("A", null), CreateGrid(("A", new GridLength(30)), (null, new GridLength())) };
+            var innerScope = new Panel();
+            innerScope.Children.AddRange(grids);
+            innerScope.SetValue(Grid.IsSharedSizeScopeProperty, true);
+
+            var outerGrid = CreateGrid(("A", new GridLength(0)));
+            var outerScope = new Panel();
+            outerScope.Children.AddRange(new[] { outerGrid, innerScope });
+
+            var root = new TestRoot();
+            root.SetValue(Grid.IsSharedSizeScopeProperty, true);
+            root.Child = outerScope;
+
+            root.Measure(new Size(50, 50));
+            root.Arrange(new Rect(new Point(), new Point(50, 50)));
+            Assert.Equal(0, outerGrid.ColumnDefinitions[0].ActualWidth);
+        }
+
+        [Fact]
+        public void Size_Is_Propagated_Between_Rows_And_Columns()
+        {
+            var grid = new Grid
+            {
+                ColumnDefinitions = new ColumnDefinitions("*,30"),
+                RowDefinitions = new RowDefinitions("*,10")
+            };
+
+            grid.ColumnDefinitions[1].SharedSizeGroup = "A";
+            grid.RowDefinitions[1].SharedSizeGroup = "A";
+
+            var root = new TestRoot();
+            root.SetValue(Grid.IsSharedSizeScopeProperty, true);
+            root.Child = grid;
+
+            root.Measure(new Size(50, 50));
+            root.Arrange(new Rect(new Point(), new Point(50, 50)));
+            Assert.Equal(30, grid.RowDefinitions[1].ActualHeight);
+        }
+
+        [Fact]
+        public void Size_Group_Changes_Are_Tracked()
+        {
+            var grids = new[] {
+                CreateGrid((null, new GridLength(0, GridUnitType.Auto)), (null, new GridLength())),
+                CreateGrid(("A", new GridLength(30)), (null, new GridLength())) };
+            var scope = new Panel();
+            scope.Children.AddRange(grids);
+
+            var root = new TestRoot();
+            root.SetValue(Grid.IsSharedSizeScopeProperty, true);
+            root.Child = scope;
+
+            root.Measure(new Size(50, 50));
+            root.Arrange(new Rect(new Point(), new Point(50, 50)));
+            Assert.Equal(0, grids[0].ColumnDefinitions[0].ActualWidth);
+
+            grids[0].ColumnDefinitions[0].SharedSizeGroup = "A";
+
+            root.Measure(new Size(51, 51));
+            root.Arrange(new Rect(new Point(), new Point(51, 51)));
+            Assert.Equal(30, grids[0].ColumnDefinitions[0].ActualWidth);
+
+            grids[0].ColumnDefinitions[0].SharedSizeGroup = null;
+
+            root.Measure(new Size(52, 52));
+            root.Arrange(new Rect(new Point(), new Point(52, 52)));
+            Assert.Equal(0, grids[0].ColumnDefinitions[0].ActualWidth);
+        }
+
+        [Fact]
+        public void Collection_Changes_Are_Tracked()
+        {
+            var grid = CreateGrid(
+                ("A", new GridLength(20)),
+                ("A", new GridLength(30)),
+                ("A", new GridLength(40)),
+                (null, new GridLength()));
+
+            var scope = new Panel();
+            scope.Children.Add(grid);
+
+            var root = new TestRoot();
+            root.SetValue(Grid.IsSharedSizeScopeProperty, true);
+            root.Child = scope;
+
+            grid.Measure(new Size(200, 200));
+            grid.Arrange(new Rect(new Point(), new Point(200, 200)));
+            Assert.All(grid.ColumnDefinitions.Where(cd => cd.SharedSizeGroup == "A"), cd => Assert.Equal(40, cd.ActualWidth));
+
+            grid.ColumnDefinitions.RemoveAt(2);
+
+            grid.Measure(new Size(200, 200));
+            grid.Arrange(new Rect(new Point(), new Point(200, 200)));
+            Assert.All(grid.ColumnDefinitions.Where(cd => cd.SharedSizeGroup == "A"), cd => Assert.Equal(30, cd.ActualWidth));
+
+            grid.ColumnDefinitions.Insert(1, new ColumnDefinition { Width = new GridLength(35), SharedSizeGroup = "A" });
+
+            grid.Measure(new Size(200, 200));
+            grid.Arrange(new Rect(new Point(), new Point(200, 200)));
+            Assert.All(grid.ColumnDefinitions.Where(cd => cd.SharedSizeGroup == "A"), cd => Assert.Equal(35, cd.ActualWidth));
+
+            grid.ColumnDefinitions[1] = new ColumnDefinition { Width = new GridLength(10), SharedSizeGroup = "A" };
+
+            grid.Measure(new Size(200, 200));
+            grid.Arrange(new Rect(new Point(), new Point(200, 200)));
+            Assert.All(grid.ColumnDefinitions.Where(cd => cd.SharedSizeGroup == "A"), cd => Assert.Equal(30, cd.ActualWidth));
+
+            grid.ColumnDefinitions[1] = new ColumnDefinition { Width = new GridLength(50), SharedSizeGroup = "A" };
+
+            grid.Measure(new Size(200, 200));
+            grid.Arrange(new Rect(new Point(), new Point(200, 200)));
+            Assert.All(grid.ColumnDefinitions.Where(cd => cd.SharedSizeGroup == "A"), cd => Assert.Equal(50, cd.ActualWidth));
+        }
+
+        [Fact]
+        public void Size_Priorities_Are_Maintained()
+        {
+            var sizers = new List<Control>();
+            var grid = CreateGrid(
+                ("A", new GridLength(20)), 
+                ("A", new GridLength(20, GridUnitType.Auto)), 
+                ("A", new GridLength(1, GridUnitType.Star)), 
+                ("A", new GridLength(1, GridUnitType.Star)),
+                (null, new GridLength()));
+            for (int i = 0; i < 3; i++)
+                sizers.Add(AddSizer(grid, i, 6 + i * 6));
+            var scope = new Panel();
+            scope.Children.Add(grid);
+
+            var root = new TestRoot();
+            root.SetValue(Grid.IsSharedSizeScopeProperty, true);
+            root.Child = scope;
+
+            grid.Measure(new Size(100, 100));
+            grid.Arrange(new Rect(new Point(), new Point(100, 100)));
+            // all in group are equal to the first fixed column
+            Assert.All(grid.ColumnDefinitions.Where(cd => cd.SharedSizeGroup == "A"), cd => Assert.Equal(20, cd.ActualWidth));
+
+            grid.ColumnDefinitions[0].SharedSizeGroup = null;
+
+            grid.Measure(new Size(100, 100));
+            grid.Arrange(new Rect(new Point(), new Point(100, 100)));
+            // all in group are equal to width (MinWidth) of the sizer in the second column
+            Assert.All(grid.ColumnDefinitions.Where(cd => cd.SharedSizeGroup == "A"), cd => Assert.Equal(6 + 1 * 6, cd.ActualWidth));
+
+            grid.ColumnDefinitions[1].SharedSizeGroup = null;
+
+            grid.Measure(new Size(double.PositiveInfinity, 100));
+            grid.Arrange(new Rect(new Point(), new Point(100, 100)));
+            // with no constraint star columns default to the MinWidth of the sizer in the column
+            Assert.All(grid.ColumnDefinitions.Where(cd => cd.SharedSizeGroup == "A"), cd => Assert.Equal(6 + 2 * 6, cd.ActualWidth));
+        }
+
+        // grid creators
+        private Grid CreateGrid(params string[] columnGroups)
+        {
+            return CreateGrid(columnGroups.Select(s => (s, ColumnDefinition.WidthProperty.GetDefaultValue(typeof(ColumnDefinition)))).ToArray());
+        }
+
+        private Grid CreateGrid(params (string name, GridLength width)[] columns)
+        {
+            return CreateGrid(columns.Select(c =>
+                (c.name, c.width, ColumnDefinition.MinWidthProperty.GetDefaultValue(typeof(ColumnDefinition)))).ToArray());
+        }
+
+        private Grid CreateGrid(params (string name, GridLength width, double minWidth)[] columns)
+        {
+            return CreateGrid(columns.Select(c =>
+                (c.name, c.width, c.minWidth, ColumnDefinition.MaxWidthProperty.GetDefaultValue(typeof(ColumnDefinition)))).ToArray());
+        }
+
+        private Grid CreateGrid(params (string name, GridLength width, double minWidth, double maxWidth)[] columns)
+        {
+            var columnDefinitions = new ColumnDefinitions();
+
+            columnDefinitions.AddRange(
+                    columns.Select(c => new ColumnDefinition
+                    {
+                        SharedSizeGroup = c.name,
+                        Width = c.width,
+                        MinWidth = c.minWidth,
+                        MaxWidth = c.maxWidth
+                    })
+                );
+            var grid = new Grid
+            {
+                ColumnDefinitions = columnDefinitions
+            };
+
+            return grid;
+        }
+
+        private Control AddSizer(Grid grid, int column, double size = 30)
+        {
+            var ctrl = new Control {  MinWidth = size, MinHeight = size };
+            ctrl.SetValue(Grid.ColumnProperty,column);
+            grid.Children.Add(ctrl);
+            return ctrl;
+        }
+    }
+}
diff --git a/tests/Avalonia.Controls.UnitTests/WindowTests.cs b/tests/Avalonia.Controls.UnitTests/WindowTests.cs
index 570cebe0e5..adf9bd9cec 100644
--- a/tests/Avalonia.Controls.UnitTests/WindowTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/WindowTests.cs
@@ -62,9 +62,11 @@ namespace Avalonia.Controls.UnitTests
         {
             using (UnitTestApplication.Start(TestServices.StyledWindow))
             {
+                var parent = new Window();
+                parent.Show();
                 var window = new Window();
 
-                var task = window.ShowDialog();
+                var task = window.ShowDialog(parent);
 
                 Assert.True(window.IsVisible);
             }
@@ -258,12 +260,13 @@ namespace Avalonia.Controls.UnitTests
         {
             using (UnitTestApplication.Start(TestServices.StyledWindow))
             {
+                var parent = new Mock<IWindowImpl>();
                 var windowImpl = new Mock<IWindowImpl>();
                 windowImpl.SetupProperty(x => x.Closed);
                 windowImpl.Setup(x => x.Scaling).Returns(1);
 
                 var target = new Window(windowImpl.Object);
-                var task = target.ShowDialog<bool>();
+                var task = target.ShowDialog<bool>(parent.Object);
 
                 windowImpl.Object.Closed();
 
diff --git a/tests/Avalonia.Layout.UnitTests/FullLayoutTests.cs b/tests/Avalonia.Layout.UnitTests/FullLayoutTests.cs
index b8b9b69b6c..78d0efcbf9 100644
--- a/tests/Avalonia.Layout.UnitTests/FullLayoutTests.cs
+++ b/tests/Avalonia.Layout.UnitTests/FullLayoutTests.cs
@@ -21,6 +21,7 @@ using Xunit;
 using Avalonia.Media;
 using System;
 using System.Collections.Generic;
+using Avalonia.Controls.UnitTests;
 using Avalonia.UnitTests;
 
 namespace Avalonia.Layout.UnitTests
@@ -197,6 +198,7 @@ namespace Avalonia.Layout.UnitTests
             windowImpl.SetupGet(x => x.Scaling).Returns(1);
 
             AvaloniaLocator.CurrentMutable
+                .Bind<IStandardCursorFactory>().ToConstant(new CursorFactoryMock())
                 .Bind<IAssetLoader>().ToConstant(new AssetLoader())
                 .Bind<IInputManager>().ToConstant(new Mock<IInputManager>().Object)
                 .Bind<IGlobalStyles>().ToConstant(globalStyles.Object)