diff --git a/samples/Avalonia.Labs.Catalog/ViewModels/ContentDialogViewModel.cs b/samples/Avalonia.Labs.Catalog/ViewModels/ContentDialogViewModel.cs
new file mode 100644
index 0000000..b4a6775
--- /dev/null
+++ b/samples/Avalonia.Labs.Catalog/ViewModels/ContentDialogViewModel.cs
@@ -0,0 +1,156 @@
+using System.Threading.Tasks;
+using System;
+using Avalonia.Labs.Catalog.Views;
+using Avalonia.Labs.Controls;
+using ReactiveUI;
+
+namespace Avalonia.Labs.Catalog.ViewModels;
+
+internal enum DialogMode
+{
+    Default,
+    Deferal,
+    Input,
+}
+
+internal class ContentDialogViewModel : ViewModelBase
+{
+    static ContentDialogViewModel()
+    {
+        ViewLocator.Register(typeof(ContentDialogViewModel), () => new ContentDialogView());
+    }
+
+    public ContentDialogViewModel()
+    {
+        Title = "ContentDialog";
+    }
+
+    public string? DialogTitle
+    {
+        get => _dialogTitle;
+        set => this.RaiseAndSetIfChanged(ref _dialogTitle, value);
+    }
+
+    public string? Content
+    {
+        get => _content;
+        set => this.RaiseAndSetIfChanged(ref _content, value);
+    }
+
+    public string PrimaryButtonText
+    {
+        get => _primaryText;
+        set => this.RaiseAndSetIfChanged(ref _primaryText, value);
+    }
+
+    public string SecondaryButtonText
+    {
+        get => _secondaryText;
+        set => this.RaiseAndSetIfChanged(ref _secondaryText, value);
+    }
+
+    public string CloseButtonText
+    {
+        get => _closeText;
+        set => this.RaiseAndSetIfChanged(ref _closeText, value);
+    }
+
+    public bool FullSizeDesired
+    {
+        get => _fullSize;
+        set => this.RaiseAndSetIfChanged(ref _fullSize, value);
+    }
+
+    public ContentDialogButton[] ContentDialogButtons { get; } = Enum.GetValues<ContentDialogButton>();
+
+    public ContentDialogButton ContentDialogDefaultButton
+    {
+        get => _defaultButton;
+        set => this.RaiseAndSetIfChanged(ref _defaultButton, value);
+    }
+
+    public bool IsPrimaryButtonEnabled
+    {
+        get => _primaryEnabled;
+        set => this.RaiseAndSetIfChanged(ref _primaryEnabled, value);
+    }
+
+    public bool IsSecondaryButtonEnabled
+    {
+        get => _secondaryEnabled;
+        set => this.RaiseAndSetIfChanged(ref _secondaryEnabled, value);
+    }
+
+
+    public async void LaunchDialog(object? parameter)
+    {
+        bool hasDeferral = false;
+        ContentDialog? dialog = default;
+        switch (parameter)
+        {
+            case DialogMode.Input:
+                dialog = new ContentDialog()
+                {
+                    Title = "Let's go ...",
+                    PrimaryButtonText = "Ok :-)",
+                    SecondaryButtonText = "Not OK :-(",
+                    CloseButtonText = "Leave me alone!"
+                };
+
+                var viewModel = new CustomContentDialogViewModel(dialog);
+                dialog.Content = new ContentDialogInputExample()
+                {
+                    DataContext = viewModel
+                };
+                break;
+            case DialogMode.Deferal:
+            default:
+                dialog = new ContentDialog
+                {
+                    PrimaryButtonText = PrimaryButtonText,
+                    SecondaryButtonText = SecondaryButtonText,
+                    CloseButtonText = CloseButtonText,
+                    Title = DialogTitle,
+                    Content = Content,
+                    IsPrimaryButtonEnabled = IsPrimaryButtonEnabled,
+                    IsSecondaryButtonEnabled = IsSecondaryButtonEnabled,
+                    DefaultButton = ContentDialogDefaultButton,
+                    FullSizeDesired = FullSizeDesired
+                };
+                hasDeferral = parameter is DialogMode.Deferal;
+                break;
+        }
+
+        if (hasDeferral)
+        {
+            dialog.PrimaryButtonClick += OnPrimaryButtonClick;
+            await dialog.ShowAsync();
+            dialog.PrimaryButtonClick -= OnPrimaryButtonClick;
+        }
+        else
+        {
+            await dialog.ShowAsync();
+        }
+    }
+
+    private async void OnPrimaryButtonClick(object? sender, ContentDialogButtonClickEventArgs args)
+    {
+        var def = args.GetDeferral();
+        await Task.Delay(3000);
+        def.Complete();
+    }
+
+
+
+
+    //private string _title = "Title Here";
+    private string _content = "Dialog message here (doesn't have to be a string, can be anything)";
+    private string _primaryText = "Primary Button";
+    private string _secondaryText = "Secondary Button";
+    private string _closeText = "Close Button";
+    private bool _fullSize;
+    private ContentDialogButton _defaultButton;
+    private bool _primaryEnabled = true;
+    private bool _secondaryEnabled = true;
+    private string? _dialogTitle = "Title Here";
+}
diff --git a/samples/Avalonia.Labs.Catalog/ViewModels/CustomContentDialogViewModel.cs b/samples/Avalonia.Labs.Catalog/ViewModels/CustomContentDialogViewModel.cs
new file mode 100644
index 0000000..0a07a9f
--- /dev/null
+++ b/samples/Avalonia.Labs.Catalog/ViewModels/CustomContentDialogViewModel.cs
@@ -0,0 +1,85 @@
+using System;
+using Avalonia.Labs.Controls;
+using ReactiveUI;
+
+namespace Avalonia.Labs.Catalog.ViewModels;
+
+class CustomContentDialogViewModel : ViewModelBase
+{
+    private readonly ContentDialog dialog;
+
+    public CustomContentDialogViewModel(ContentDialog dialog)
+    {
+        if (dialog is null)
+        {
+            throw new ArgumentNullException(nameof(dialog));
+        }
+
+        this.dialog = dialog;
+        dialog.Closed += DialogOnClosed;
+    }
+
+    private void DialogOnClosed(object? sender, ContentDialogClosedEventArgs args)
+    {
+        dialog.Closed -= DialogOnClosed;
+
+        var resultHint = new ContentDialog()
+        {
+            Content = $"You chose \"{args.Result}\"",
+            Title = "Result",
+            PrimaryButtonText = "Thanks"
+        };
+
+        _ = resultHint.ShowAsync();
+    }
+
+    private string? _UserInput;
+
+    /// <summary>
+    /// Gets or sets the user input to check 
+    /// </summary>
+    public string? UserInput
+    {
+        get => _UserInput;
+        set
+        {
+            this.RaiseAndSetIfChanged(ref _UserInput, value);
+            HandleUserInput();
+        }
+    }
+
+    private void HandleUserInput()
+    {
+        switch (UserInput?.ToLowerInvariant())
+        {
+            case "accept":
+            case "ok":
+                dialog.Hide(ContentDialogResult.Primary);
+                break;
+
+            case "dismiss":
+            case "not ok":
+                dialog.Hide(ContentDialogResult.Secondary);
+                break;
+
+            case "cancel":
+            case "close":
+            case "hide":
+                dialog.Hide();
+                break;
+        }
+    }
+
+    private static readonly string[] _AvailableKeyWords = new[]
+    {
+    "Accept",
+    "OK",
+    "Dismiss",
+    "Not OK",
+    "Close",
+    "Cancel",
+    "Hide"
+};
+
+    public string[] AvailableKeyWords => _AvailableKeyWords;
+}
diff --git a/samples/Avalonia.Labs.Catalog/Views/ContentDialogInputExample.axaml b/samples/Avalonia.Labs.Catalog/Views/ContentDialogInputExample.axaml
new file mode 100644
index 0000000..dbed9aa
--- /dev/null
+++ b/samples/Avalonia.Labs.Catalog/Views/ContentDialogInputExample.axaml
@@ -0,0 +1,20 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:vm="clr-namespace:Avalonia.Labs.Catalog.ViewModels"
+             mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
+             Padding="0, 10"
+             x:DataType="vm:CustomContentDialogViewModel"
+             x:Class="Avalonia.Labs.Catalog.Views.ContentDialogInputExample">
+  <StackPanel Spacing="10" MinWidth="400">
+    <TextBlock>Try out some magic keywords</TextBlock>
+    <AutoCompleteBox FilterMode="StartsWithOrdinal"
+                     Watermark="Write a keyword, for example 'ok', 'not ok' or 'hide'"
+                     Text="{CompiledBinding UserInput}"
+                     ItemsSource="{Binding AvailableKeyWords}"
+                     AttachedToVisualTree="InputField_OnAttachedToVisualTree" />
+    <TextBox Text="" AcceptsReturn="True"
+             />
+  </StackPanel>
+</UserControl>
diff --git a/samples/Avalonia.Labs.Catalog/Views/ContentDialogInputExample.axaml.cs b/samples/Avalonia.Labs.Catalog/Views/ContentDialogInputExample.axaml.cs
new file mode 100644
index 0000000..14a36fd
--- /dev/null
+++ b/samples/Avalonia.Labs.Catalog/Views/ContentDialogInputExample.axaml.cs
@@ -0,0 +1,25 @@
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Threading;
+
+namespace Avalonia.Labs.Catalog.Views;
+
+public partial class ContentDialogInputExample : UserControl
+{
+    public ContentDialogInputExample()
+    {
+        InitializeComponent();
+    }
+
+    private void InputField_OnAttachedToVisualTree(object sender, VisualTreeAttachmentEventArgs e)
+    {
+        // We will set the focus into our input field just after it got attached to the visual tree.
+        if (sender is InputElement inputElement)
+        {
+            Dispatcher.UIThread.InvokeAsync(() =>
+            {
+                inputElement.Focus(NavigationMethod.Unspecified, KeyModifiers.None);
+            });
+        }
+    }
+}
diff --git a/samples/Avalonia.Labs.Catalog/Views/ContentDialogView.axaml b/samples/Avalonia.Labs.Catalog/Views/ContentDialogView.axaml
new file mode 100644
index 0000000..1248ab8
--- /dev/null
+++ b/samples/Avalonia.Labs.Catalog/Views/ContentDialogView.axaml
@@ -0,0 +1,58 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
+             xmlns:vm="using:Avalonia.Labs.Catalog.ViewModels"
+             x:Class="Avalonia.Labs.Catalog.Views.ContentDialogView">
+  <DockPanel>
+    <StackPanel Orientation="Vertical" 
+                Spacing="4" 
+                MaxWidth="250"
+                DockPanel.Dock="Right">
+      <Expander Header="Enabled Buttons" IsExpanded="True">
+        <StackPanel Orientation="Vertical">
+          <CheckBox Content="IsPrimaryButtonEnabled" IsChecked="{Binding IsPrimaryButtonEnabled}"/>
+          <CheckBox Content="IsSecondaryButtonEnabled" IsChecked="{Binding IsSecondaryButtonEnabled}"/>
+        </StackPanel>
+      </Expander>
+      <Expander Header="Default Button">
+        <ComboBox Name="DefButtonSelector" MinWidth="90"
+                  ItemsSource="{Binding ContentDialogButtons}"
+                  SelectedItem="{Binding ContentDialogDefaultButton}" />
+      </Expander>
+      <Expander Header="Content">
+        <StackPanel Orientation="Vertical" Spacing="4">
+          <TextBlock Text="Title"/>
+          <TextBox Text="{Binding Title}" />
+          <TextBlock Text="Content"/>
+          <TextBox Text="{Binding Content}" />
+          <TextBlock Text="PrimaryButtonText"/>
+          <TextBox Text="{Binding PrimaryButtonText}" />
+          <TextBlock Text="SecondaryButtonText"/>
+          <TextBox Text="{Binding SecondaryButtonText}" />
+          <TextBlock Text="CloseButtonText"/>
+          <TextBox Text="{Binding CloseButtonText}" />
+        </StackPanel>
+      </Expander>
+
+      <StackPanel Orientation="Vertical" Margin="20 0">
+        <CheckBox Content="FullSizeDesired" IsChecked="{Binding FullSizeDesired}"
+                  ToolTip.ShowDelay="100"
+                  ToolTip.Tip="Full size stretches the dialog to &quot;full screen&quot;. &#x0a; Though, it just stretches it to the height size of a Content Dialog. &#x0a;"/>
+      </StackPanel>
+    </StackPanel>
+
+    <StackPanel Spacing="8">
+      <Button Content="Launch ContentDialog"
+                 Command="{Binding LaunchDialog}"
+                 CommandParameter="{x:Static vm:DialogMode.Default}" />
+      <Button Content="Launch ContentDialog with Primary Button deferral"
+                 Command="{Binding LaunchDialog}"
+                 CommandParameter="{x:Static vm:DialogMode.Deferal}" />
+      <Button Content="Show Input"
+                 Command="{Binding LaunchDialog}"
+                 CommandParameter="{x:Static vm:DialogMode.Input}"/>
+    </StackPanel>
+  </DockPanel>
+</UserControl>
diff --git a/samples/Avalonia.Labs.Catalog/Views/ContentDialogView.axaml.cs b/samples/Avalonia.Labs.Catalog/Views/ContentDialogView.axaml.cs
new file mode 100644
index 0000000..78f2f2d
--- /dev/null
+++ b/samples/Avalonia.Labs.Catalog/Views/ContentDialogView.axaml.cs
@@ -0,0 +1,13 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+
+namespace Avalonia.Labs.Catalog.Views;
+
+public partial class ContentDialogView : UserControl
+{
+    public ContentDialogView()
+    {
+        InitializeComponent();
+    }
+}
\ No newline at end of file
diff --git a/samples/Avalonia.Labs.Catalog/Views/WelcomeView.axaml b/samples/Avalonia.Labs.Catalog/Views/WelcomeView.axaml
index 85b573d..5b51c89 100644
--- a/samples/Avalonia.Labs.Catalog/Views/WelcomeView.axaml
+++ b/samples/Avalonia.Labs.Catalog/Views/WelcomeView.axaml
@@ -41,6 +41,17 @@
         <Label FontSize="18"
                VerticalAlignment="Center">Async Image</Label>
       </Button>
+      <Button HorizontalAlignment="Stretch"
+              Height="60"
+              Command="{Binding NavigateTo}"
+              CornerRadius="10"
+              Margin="0,5">
+        <Button.CommandParameter>
+          <viewModels:ContentDialogViewModel/>
+        </Button.CommandParameter>
+        <Label FontSize="18"
+               VerticalAlignment="Center">ContentDialog</Label>
+      </Button>
       <Button HorizontalAlignment="Stretch"
               Height="60"
               Command="{Binding NavigateTo}"
diff --git a/src/Avalonia.Labs.Controls/Avalonia.Labs.Controls.csproj b/src/Avalonia.Labs.Controls/Avalonia.Labs.Controls.csproj
index 546dc57..7a75c5c 100644
--- a/src/Avalonia.Labs.Controls/Avalonia.Labs.Controls.csproj
+++ b/src/Avalonia.Labs.Controls/Avalonia.Labs.Controls.csproj
@@ -16,4 +16,14 @@
     <AvaloniaResource Include="**/*.xaml" />
     <AvaloniaResource Include="**/*.axaml" />
   </ItemGroup>
+
+  <ItemGroup>
+    <AvaloniaXaml Remove="Themes\Controls\ContentDialog.axaml" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <AvaloniaResource Update="Themes\Controls\ContentDialog.axaml">
+      <SubType>Designer</SubType>
+    </AvaloniaResource>
+  </ItemGroup>
 </Project>
diff --git a/src/Avalonia.Labs.Controls/CompositeDisposable.cs b/src/Avalonia.Labs.Controls/CompositeDisposable.cs
new file mode 100644
index 0000000..dfa2f2a
--- /dev/null
+++ b/src/Avalonia.Labs.Controls/CompositeDisposable.cs
@@ -0,0 +1,78 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Avalonia.Labs.Controls;
+
+internal class CompositeDisposable : IList<IDisposable>, IDisposable
+{
+    readonly List<IDisposable> _disposables;
+    public CompositeDisposable(int capacity)
+    {
+        _disposables = new List<IDisposable>(capacity);
+    }
+
+    public IDisposable this[int index]
+    {
+        get => _disposables[index];
+        set
+        {
+            var old = _disposables[index];
+            old?.Dispose();
+            _disposables[index] = value;
+        }
+    }
+
+    public int Count => _disposables.Count;
+
+    public bool IsReadOnly => false;
+
+    public void Add(IDisposable item) =>
+        _disposables.Add(item);
+
+    public void Clear() =>
+        Dispose();
+
+
+    public bool Contains(IDisposable item) =>
+        _disposables.Contains(item);
+
+    public void CopyTo(IDisposable[] array, int arrayIndex) =>
+        _disposables.CopyTo(array, arrayIndex);
+
+    public void Dispose()
+    {
+        var start = _disposables.Count - 1;
+        for (int i = start; i >= 0; i--)
+        {
+            _disposables[i].Dispose();
+            _disposables.RemoveAt(i);
+        }
+    }
+
+    public IEnumerator<IDisposable> GetEnumerator() =>
+        _disposables.GetEnumerator();
+
+    public int IndexOf(IDisposable item) =>
+        _disposables.IndexOf(item);
+
+    public void Insert(int index, IDisposable item) =>
+        _disposables.Insert(index, item);
+
+    public bool Remove(IDisposable item)
+    {
+        var result = _disposables.Remove(item);
+        item?.Dispose();
+        return result;
+    }
+
+    public void RemoveAt(int index)
+    {
+        var item = _disposables[index];
+        _disposables.RemoveAt(index);
+        item?.Dispose();
+    }
+
+    IEnumerator IEnumerable.GetEnumerator() =>
+        _disposables.GetEnumerator();
+}
diff --git a/src/Avalonia.Labs.Controls/ContentDialog/ContentDialog.cs b/src/Avalonia.Labs.Controls/ContentDialog/ContentDialog.cs
new file mode 100644
index 0000000..7f3831f
--- /dev/null
+++ b/src/Avalonia.Labs.Controls/ContentDialog/ContentDialog.cs
@@ -0,0 +1,626 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Avalonia.Controls.ApplicationLifetimes;
+using Avalonia.Controls.Presenters;
+using Avalonia.Controls.Primitives;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Interactivity;
+using Avalonia.Logging;
+using Avalonia.Threading;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Labs.Controls;
+
+/// <summary>
+/// Presents a asynchronous dialog to the user.
+/// </summary>
+public partial class ContentDialog : ContentControl, ICustomKeyboardNavigation
+{
+    public ContentDialog()
+    {
+        PseudoClasses.Add(SharedPseudoclasses.s_pcHidden);
+    }
+
+    protected override void OnApplyTemplate(TemplateAppliedEventArgs e)
+    {
+        if (_primaryButton != null)
+            _primaryButton.Click -= OnButtonClick;
+        if (_secondaryButton != null)
+            _secondaryButton.Click -= OnButtonClick;
+        if (_closeButton != null)
+            _closeButton.Click -= OnButtonClick;
+
+        base.OnApplyTemplate(e);
+
+        _primaryButton = e.NameScope.Get<Button>(s_tpPrimaryButton);
+        _primaryButton.Click += OnButtonClick;
+        _secondaryButton = e.NameScope.Get<Button>(s_tpSecondaryButton);
+        _secondaryButton.Click += OnButtonClick;
+        _closeButton = e.NameScope.Get<Button>(s_tpCloseButton);
+        _closeButton.Click += OnButtonClick;
+
+        // v2- Removed this as I don't think its necessary anymore (called from ShowAsync)
+        //SetupDialog();
+    }
+
+    protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
+    {
+        base.OnPropertyChanged(change);
+
+        if (change.Property == FullSizeDesiredProperty)
+        {
+            OnFullSizedDesiredChanged(change);
+        }
+    }
+
+    protected override bool RegisterContentPresenter(ContentPresenter presenter)
+    {
+        if (presenter.Name == "Content")
+            return true;
+
+        return base.RegisterContentPresenter(presenter);
+    }
+
+    protected override void OnKeyDown(KeyEventArgs e)
+    {
+        if (e.Handled)
+        {
+            base.OnKeyDown(e);
+            return;
+        }
+
+        switch (e.Key)
+        {
+            case Key.Escape:
+                HideCore();
+                e.Handled = true;
+                break;
+
+            case Key.Enter:
+                var defButton = DefaultButton;
+
+                // v2 - Only handle 'Enter' if the default button is set
+                //      Otherwise, we'll let the event go as normal - if focus is currently
+                //      on a button, 'Enter' should invoke that button
+
+                switch (defButton)
+                {
+                    case ContentDialogButton.Primary:
+                        OnButtonClick(_primaryButton, null);
+                        break;
+
+                    case ContentDialogButton.Secondary:
+                        OnButtonClick(_secondaryButton, null);
+                        break;
+
+                    case ContentDialogButton.Close:
+                        OnButtonClick(_closeButton, null);
+                        break;
+                }
+                e.Handled = true;
+
+                break;
+        }
+        base.OnKeyDown(e);
+    }
+
+
+    /// <summary>
+    /// Begins an asynchronous operation to show the dialog.
+    /// </summary>
+    public async Task<ContentDialogResult> ShowAsync() => await ShowAsyncCore(null);
+
+    /// <summary>
+    /// Begins an asynchronous operation to show the dialog using the specified window
+    /// </summary>
+    public async Task<ContentDialogResult> ShowAsync(Window w) => await ShowAsyncCore(w);
+
+    /// <summary>
+    /// Shows the content dialog on the specified window asynchronously.
+    /// </summary>
+    /// <remarks>
+    /// Note that the placement parameter is not implemented and only accepts <see cref="ContentDialogPlacement.Popup"/>
+    /// </remarks>
+    private async Task<ContentDialogResult> ShowAsyncCore(Window? window, ContentDialogPlacement placement = ContentDialogPlacement.Popup)
+    {
+        if (placement == ContentDialogPlacement.InPlace)
+            throw new NotImplementedException("InPlace not implemented yet");
+        _tcs = new TaskCompletionSource<ContentDialogResult>();
+
+        OnOpening();
+
+        if (Parent != null)
+        {
+            _originalHost = (Control)Parent;
+            switch (_originalHost)
+            {
+                case Panel p:
+                    _originalHostIndex = p.Children.IndexOf(this);
+                    p.Children.Remove(this);
+                    break;
+                case Decorator d:
+                    d.Child = null;
+                    break;
+                case ContentControl cc:
+                    cc.Content = null;
+                    break;
+                case ContentPresenter cp:
+                    cp.Content = null;
+                    break;
+            }
+        }
+
+        _host ??= new DialogHost();
+
+        _host.Content = this;
+
+        OverlayLayer? ol = null;
+        var topLevel = GetTopLevel(window);
+
+        ol = OverlayLayer.GetOverlayLayer(topLevel!);
+        _lastFocus = topLevel!.FocusManager?.GetFocusedElement();
+
+        _keyEventFilter?.Dispose();
+        _keyEventFilter = new CompositeDisposable(2)
+        {
+            KeyDownEvent.AddClassHandler<TopLevel>(KeyFilter, RoutingStrategies.Tunnel),
+            KeyUpEvent.AddClassHandler<TopLevel>(KeyFilter, RoutingStrategies.Tunnel),
+        };
+
+        if (ol == null)
+            throw new InvalidOperationException();
+
+        ol.Children.Add(_host);
+
+        // v2 - Added this so dialog materializes in the Visual Tree now since for some reason
+        //      items in the OverlayLayer materialize at the absolute last moment making init
+        //      a very difficult task to do
+        // v2-preview6: This doesn't appear necessary anymore...will preserve this for now
+        // but has to be removed to solve GH#315
+        //(ol.GetVisualRoot() as ILayoutRoot).LayoutManager.ExecuteInitialLayoutPass();
+
+        IsVisible = true;
+        ol.UpdateLayout();
+        ShowCore();
+        SetupDialog();
+        return await _tcs.Task;
+
+        static TopLevel GetTopLevel(Window? window)
+        {
+            return window ??
+                Application.Current!.ApplicationLifetime switch
+                {
+                    IClassicDesktopStyleApplicationLifetime cls when cls.MainWindow is not null =>
+                        cls.Windows.FirstOrDefault(x => x.IsActive)
+                            ?? cls.MainWindow,
+                    ISingleViewApplicationLifetime sl when sl.MainView is not null =>
+                        TopLevel.GetTopLevel(sl.MainView)
+                            ?? throw new InvalidOperationException(),
+                    _ => throw new InvalidOperationException()
+                };
+        }
+
+        void KeyFilter(TopLevel topLevel, KeyEventArgs arg)
+        {
+            if (topLevel.FocusManager?.GetFocusedElement() is Visual focusedElement)
+            {
+                arg.Handled = arg.Key == Key.Enter
+                    && !this.GetVisualDescendants().Any(v => ReferenceEquals(v, focusedElement));
+            }
+        }
+    }
+
+    /// <summary>
+    /// Closes the current <see cref="ContentDialog"/> without a result (<see cref="ContentDialogResult"/>.<see cref="ContentDialogResult.None"/>)
+    /// </summary>
+    public void Hide() => Hide(ContentDialogResult.None);
+
+    /// <summary>
+    /// Closes the current <see cref="ContentDialog"/> with the given <see cref="ContentDialogResult"/> <para>ddd</para>
+    /// </summary>
+    /// <param name="dialogResult">The <see cref="ContentDialogResult"/> to return</param>
+    public void Hide(ContentDialogResult dialogResult)
+    {
+        _result = dialogResult;
+        HideCore();
+    }
+
+    /// <summary>
+    /// Called when the primary button is invoked
+    /// </summary>
+    protected virtual void OnPrimaryButtonClick(ContentDialogButtonClickEventArgs args)
+    {
+        PrimaryButtonClick?.Invoke(this, args);
+    }
+
+    /// <summary>
+    /// Called when the secondary button is invoked
+    /// </summary>
+    protected virtual void OnSecondaryButtonClick(ContentDialogButtonClickEventArgs args)
+    {
+        SecondaryButtonClick?.Invoke(this, args);
+    }
+
+    /// <summary>
+    /// Called when the close button is invoked
+    /// </summary>
+    protected virtual void OnCloseButtonClick(ContentDialogButtonClickEventArgs args)
+    {
+        CloseButtonClick?.Invoke(this, args);
+    }
+
+    /// <summary>
+    /// Called when the ContentDialog is requested to be opened
+    /// </summary>
+    protected virtual void OnOpening()
+    {
+        Opening?.Invoke(this, EventArgs.Empty);
+    }
+
+    /// <summary>
+    /// Called after the ContentDialog is initialized but just before its presented on screen
+    /// </summary>
+    protected virtual void OnOpened()
+    {
+        Opened?.Invoke(this, EventArgs.Empty);
+    }
+
+    /// <summary>
+    /// Called when the ContentDialog has been requested to close, but before it actually closes
+    /// </summary>
+    /// <param name="args"></param>
+    protected virtual void OnClosing(ContentDialogClosingEventArgs args)
+    {
+        Closing?.Invoke(this, args);
+    }
+
+    /// <summary>
+    /// Called when the ContentDialog has been closed and removed from the tree
+    /// </summary>
+    protected virtual void OnClosed(ContentDialogClosedEventArgs args)
+    {
+        Closed?.Invoke(this, args);
+    }
+
+    private void ShowCore()
+    {
+        IsVisible = true;
+        PseudoClasses.Set(SharedPseudoclasses.s_pcHidden, false);
+        PseudoClasses.Set(SharedPseudoclasses.s_pcOpen, true);
+
+        OnOpened();
+    }
+
+    private void HideCore()
+    {
+        // v2 - No longer disabling the dialog during a deferral so we need to make sure that if
+        //      multiple requests to close come in, we don't handle them
+        if (_hasDeferralActive)
+            return;
+
+        // v2- Changed to match logic in TeachingTip for deferral, fixing #239 where cancel
+        //     was being handled before the deferral.
+        var args = new ContentDialogClosingEventArgs(_result);
+
+        var deferral = new Deferral(() =>
+        {
+            Dispatcher.UIThread.VerifyAccess();
+            _hasDeferralActive = false;
+
+            if (!args.Cancel)
+            {
+                FinalCloseDialog();
+            }
+        });
+
+        args.SetDeferral(deferral);
+        _hasDeferralActive = true;
+
+        args.IncrementDeferralCount();
+        OnClosing(args);
+        args.DecrementDeferralCount();
+    }
+
+    // Internal only for UnitTests
+    internal void SetupDialog()
+    {
+        if (_primaryButton == null)
+            ApplyTemplate();
+
+        PseudoClasses.Set(s_pcPrimary, !string.IsNullOrEmpty(PrimaryButtonText));
+        PseudoClasses.Set(s_pcSecondary, !string.IsNullOrEmpty(SecondaryButtonText));
+        PseudoClasses.Set(s_pcClose, !string.IsNullOrEmpty(CloseButtonText));
+
+        var curFocus = TopLevel.GetTopLevel(this)?.FocusManager?.GetFocusedElement() as Control;
+        bool setFocus = false;
+        if (curFocus.FindAncestorOfType<ContentDialog>() == null)
+        {
+            // Only set the focus if user didn't handle doing that in Opened handler,
+            // since this is called after
+            setFocus = true;
+        }
+        IInputElement? inputElement = null;
+        var p = Presenter;
+        switch (DefaultButton)
+        {
+            case ContentDialogButton.Primary:
+                if (_primaryButton is { IsVisible: false })
+                    break;
+
+                _primaryButton?.Classes.Add(SharedPseudoclasses.s_cAccent);
+                _secondaryButton?.Classes.Remove(SharedPseudoclasses.s_cAccent);
+                _closeButton?.Classes.Remove(SharedPseudoclasses.s_cAccent);
+
+                if (setFocus)
+                {
+                    inputElement = _primaryButton;
+#if DEBUG
+                    Logger.TryGet(LogEventLevel.Debug, "ContentDialog")?.Log("SetupDialog", "Set initial focus to PrimaryButton");
+#endif
+                }
+
+                break;
+
+            case ContentDialogButton.Secondary:
+                if (_secondaryButton is { IsVisible: false })
+                    break;
+
+                _secondaryButton?.Classes.Add(SharedPseudoclasses.s_cAccent);
+                _primaryButton?.Classes.Remove(SharedPseudoclasses.s_cAccent);
+                _closeButton?.Classes.Remove(SharedPseudoclasses.s_cAccent);
+
+                if (setFocus)
+                {
+                    inputElement = _secondaryButton;
+#if DEBUG
+                    Logger.TryGet(LogEventLevel.Debug, "ContentDialog")?.Log("SetupDialog", "Set initial focus to SecondaryButton");
+#endif
+                }
+
+                break;
+
+            case ContentDialogButton.Close:
+                if (_closeButton is { IsVisible: false })
+                    break;
+
+                _closeButton?.Classes.Add(SharedPseudoclasses.s_cAccent);
+                _primaryButton?.Classes.Remove(SharedPseudoclasses.s_cAccent);
+                _secondaryButton?.Classes.Remove(SharedPseudoclasses.s_cAccent);
+
+                if (setFocus)
+                {
+                    inputElement = _closeButton;
+#if DEBUG
+                    Logger.TryGet(LogEventLevel.Debug, "ContentDialog")?.Log("SetupDialog", "Set initial focus to CloseButton");
+#endif
+                }
+
+                break;
+
+            default:
+                _closeButton?.Classes.Remove(SharedPseudoclasses.s_cAccent);
+                _primaryButton?.Classes.Remove(SharedPseudoclasses.s_cAccent);
+                _secondaryButton?.Classes.Remove(SharedPseudoclasses.s_cAccent);
+
+                break;
+        }
+
+        if (setFocus)
+        {
+
+            inputElement ??= KeyboardNavigationHandler.GetNext(this, NavigationDirection.Next) ?? this;
+
+            if (!this.IsLoaded)
+            {
+                EventHandler<RoutedEventArgs>? lh = default;
+                lh = async (s, e) =>
+                {
+                    this.Loaded -= lh;
+                    inputElement?.Focus();
+                };
+                this.Loaded += lh;
+            }
+            else
+            {
+                Avalonia.Threading.Dispatcher.UIThread.Post(state =>
+                {
+                    var next = state as IInputElement;
+                    next?.Focus();
+#if DEBUG
+                    Logger.TryGet(LogEventLevel.Debug, "ContentDialog")?.Log("SetupDialog", "Set initial focus to {next}", next);
+#endif
+                }, inputElement);
+            }
+        }
+    }
+
+    // This is the exit point for the ContentDialog
+    // This method MUST be called to finalize everything
+    private async void FinalCloseDialog()
+    {
+        // Prevent interaction when closing...double/mutliple clicking on the buttons to close
+        // the dialog was calling this multiple times, which would cause the OverlayLayer check
+        // below to fail (as this would be removed from the tree). This is a simple workaround
+        // to make sure we don't error out
+        IsHitTestVisible = false;
+        _keyEventFilter?.Dispose();
+
+        // For a better experience when animating closed, we need to make sure the
+        // focus adorner is not showing (if using keyboard) otherwise that will hang
+        // around and not fade out and it just looks weird. So focus this to force the
+        // adorner to hide, then continue forward.
+        Focus();
+
+        PseudoClasses.Set(SharedPseudoclasses.s_pcHidden, true);
+        PseudoClasses.Set(SharedPseudoclasses.s_pcOpen, false);
+
+        // Let the close animation finish (now 0.167s in new WinUI update...)
+        // We'll wait just a touch longer to be sure
+        await Task.Delay(200);
+
+        OnClosed(new ContentDialogClosedEventArgs(_result));
+
+        if (_lastFocus != null)
+        {
+            _lastFocus.Focus(NavigationMethod.Unspecified);
+            _lastFocus = null;
+        }
+
+        var ol = OverlayLayer.GetOverlayLayer(_host!);
+        // If OverlayLayer isn't found here, this may be a reentrant call (hit ESC multiple times quickly, etc)
+        // Don't fail, and return. If this isn't reentrant, there's bigger issues...
+        if (ol == null)
+            return;
+
+        ol.Children.Remove(_host!);
+
+        _host!.Content = null;
+
+        if (_originalHost != null)
+        {
+            if (_originalHost is Panel p)
+            {
+                p.Children.Insert(_originalHostIndex, this);
+            }
+            else if (_originalHost is Decorator d)
+            {
+                d.Child = this;
+            }
+            else if (_originalHost is ContentControl cc)
+            {
+                cc.Content = this;
+            }
+            else if (_originalHost is ContentPresenter cp)
+            {
+                cp.Content = this;
+            }
+        }
+
+        _tcs!.TrySetResult(_result);
+    }
+
+    private void OnButtonClick(object? sender, RoutedEventArgs? e)
+    {
+        // v2 - No longer disabling the dialog during a deferral so we need to make sure that if
+        //      multiple requests to close come in, we don't handle them
+        if (_hasDeferralActive)
+            return;
+
+        var args = new ContentDialogButtonClickEventArgs();
+
+        var deferral = new Deferral(() =>
+        {
+            Dispatcher.UIThread.VerifyAccess();
+            _hasDeferralActive = false;
+
+            if (args.Cancel)
+                return;
+
+            if (sender == _primaryButton)
+            {
+                _result = ContentDialogResult.Primary;
+            }
+            else if (sender == _secondaryButton)
+            {
+                _result = ContentDialogResult.Secondary;
+            }
+            else if (sender == _closeButton)
+            {
+                _result = ContentDialogResult.None;
+            }
+
+            HideCore();
+        });
+
+        args.SetDeferral(deferral);
+        _hasDeferralActive = true;
+
+        args.IncrementDeferralCount();
+        if (sender == _primaryButton)
+        {
+            OnPrimaryButtonClick(args);
+        }
+        else if (sender == _secondaryButton)
+        {
+            OnSecondaryButtonClick(args);
+        }
+        else if (sender == _closeButton)
+        {
+            OnCloseButtonClick(args);
+        }
+        args.DecrementDeferralCount();
+    }
+
+    private void OnFullSizedDesiredChanged(AvaloniaPropertyChangedEventArgs e)
+    {
+        bool newVal = (bool)e.NewValue!;
+        PseudoClasses.Set(s_pcFullSize, newVal);
+    }
+
+    public (bool handled, IInputElement? next) GetNext(IInputElement? element, NavigationDirection direction)
+    {
+        var children = this.GetVisualDescendants().OfType<IInputElement>()
+            .Where(x => KeyboardNavigation.GetIsTabStop((InputElement)x) && x.Focusable &&
+            x.IsEffectivelyVisible && IsEffectivelyEnabled).ToList();
+
+        if (children.Count == 0)
+            return (false, null);
+
+        var current = TopLevel.GetTopLevel(this)?.FocusManager?.GetFocusedElement();
+        if (current == null)
+            return (false, null);
+
+        if (direction == NavigationDirection.Next)
+        {
+            for (int i = 0; i < children.Count; i++)
+            {
+                if (children[i] == current)
+                {
+                    if (i == children.Count - 1)
+                    {
+                        return (true, children[0]);
+                    }
+                    else
+                    {
+                        return (true, children[i + 1]);
+                    }
+                }
+            }
+        }
+        else if (direction == NavigationDirection.Previous)
+        {
+            for (int i = children.Count - 1; i >= 0; i--)
+            {
+                if (children[i] == current)
+                {
+                    if (i == 0)
+                    {
+                        return (true, children[children.Count - 1]);
+                    }
+                    else
+                    {
+                        return (true, children[i - 1]);
+                    }
+                }
+            }
+        }
+
+        return (false, null);
+    }
+
+    // Store the last element focused before showing the dialog, so we can
+    // restore it when it closes
+    private IInputElement? _lastFocus;
+    private Control? _originalHost;
+    private int _originalHostIndex;
+    private DialogHost? _host;
+    private ContentDialogResult _result;
+    private TaskCompletionSource<ContentDialogResult>? _tcs;
+    private Button? _primaryButton;
+    private Button? _secondaryButton;
+    private Button? _closeButton;
+    private bool _hasDeferralActive;
+    private IDisposable? _keyEventFilter;
+}
diff --git a/src/Avalonia.Labs.Controls/ContentDialog/ContentDialog.properties.cs b/src/Avalonia.Labs.Controls/ContentDialog/ContentDialog.properties.cs
new file mode 100644
index 0000000..b064c73
--- /dev/null
+++ b/src/Avalonia.Labs.Controls/ContentDialog/ContentDialog.properties.cs
@@ -0,0 +1,372 @@
+using System;
+using Avalonia.Controls.Metadata;
+using Avalonia.Controls.Templates;
+using Avalonia.Controls;
+using System.Windows.Input;
+
+namespace Avalonia.Labs.Controls;
+
+[PseudoClasses(SharedPseudoclasses.s_pcHidden, SharedPseudoclasses.s_pcOpen)]
+[PseudoClasses(s_pcPrimary, s_pcSecondary, s_pcClose)]
+[PseudoClasses(s_pcFullSize)]
+[TemplatePart(s_tpPrimaryButton, typeof(Button))]
+[TemplatePart(s_tpSecondaryButton, typeof(Button))]
+[TemplatePart(s_tpCloseButton, typeof(Button))]
+public partial class ContentDialog
+{
+    /// <summary>
+    /// Defines the <see cref="CloseButtonCommand"/> property
+    /// </summary>
+    public static readonly StyledProperty<ICommand?> CloseButtonCommandProperty =
+        AvaloniaProperty.Register<ContentDialog, ICommand?>(nameof(CloseButtonCommand));
+
+    /// <summary>
+    /// Defines the <see cref="CloseButtonCommandParameter"/> property
+    /// </summary>
+    public static readonly StyledProperty<object?> CloseButtonCommandParameterProperty =
+        AvaloniaProperty.Register<ContentDialog, object?>(nameof(CloseButtonCommandParameter));
+
+    /// <summary>
+    /// Defines the <see cref="CloseButtonText"/> property
+    /// </summary>
+    public static readonly StyledProperty<string?> CloseButtonTextProperty =
+        AvaloniaProperty.Register<ContentDialog, string?>(nameof(CloseButtonText));
+
+    /// <summary>
+    /// Defines the <see cref="DefaultButton"/> property
+    /// </summary>
+    public static readonly StyledProperty<ContentDialogButton> DefaultButtonProperty =
+        AvaloniaProperty.Register<ContentDialog, ContentDialogButton>(nameof(DefaultButton), ContentDialogButton.None);
+
+    /// <summary>
+    /// Defines the <see cref="IsPrimaryButtonEnabled"/> property
+    /// </summary>
+    public static readonly StyledProperty<bool> IsPrimaryButtonEnabledProperty =
+        AvaloniaProperty.Register<ContentDialog, bool>(nameof(IsPrimaryButtonEnabled), true);
+
+    /// <summary>
+    /// Defines the <see cref="IsSecondaryButtonEnabled"/> property
+    /// </summary>
+    public static readonly StyledProperty<bool> IsSecondaryButtonEnabledProperty =
+        AvaloniaProperty.Register<ContentDialog, bool>(nameof(IsSecondaryButtonEnabled), true);
+
+    /// <summary>
+    /// Defines the <see cref="PrimaryButtonCommand"/> property
+    /// </summary>
+    public static readonly StyledProperty<ICommand?> PrimaryButtonCommandProperty =
+        AvaloniaProperty.Register<ContentDialog, ICommand?>(nameof(PrimaryButtonCommand));
+
+    /// <summary>
+    /// Defines the <see cref="PrimaryButtonCommandParameter"/> property
+    /// </summary>
+    public static readonly StyledProperty<object?> PrimaryButtonCommandParameterProperty =
+        AvaloniaProperty.Register<ContentDialog, object?>(nameof(PrimaryButtonCommandParameter));
+
+    /// <summary>
+    /// Defines the <see cref="PrimaryButtonText"/> property
+    /// </summary>
+    public static readonly StyledProperty<string?> PrimaryButtonTextProperty =
+        AvaloniaProperty.Register<ContentDialog, string?>(nameof(PrimaryButtonText));
+
+    /// <summary>
+    /// Defines the <see cref="SecondaryButtonCommand"/> property
+    /// </summary>
+    public static readonly StyledProperty<ICommand?> SecondaryButtonCommandProperty =
+        AvaloniaProperty.Register<ContentDialog, ICommand?>(nameof(SecondaryButtonCommand));
+
+    /// <summary>
+    /// Defines the <see cref="SecondaryButtonCommandParameter"/> property
+    /// </summary>
+    public static readonly StyledProperty<object?> SecondaryButtonCommandParameterProperty =
+        AvaloniaProperty.Register<ContentDialog, object?>(nameof(SecondaryButtonCommandParameter));
+
+    /// <summary>
+    /// Defines the <see cref="SecondaryButtonText"/> property
+    /// </summary>
+    public static readonly StyledProperty<string?> SecondaryButtonTextProperty =
+        AvaloniaProperty.Register<ContentDialog, string?>(nameof(SecondaryButtonText));
+
+    /// <summary>
+    /// Defines the <see cref="Title"/> property
+    /// </summary>
+    public static readonly StyledProperty<object?> TitleProperty =
+        AvaloniaProperty.Register<ContentDialog, object?>(nameof(Title), "");
+
+    /// <summary>
+    /// Defines the <see cref="TitleTemplate"/> property
+    /// </summary>
+    public static readonly StyledProperty<IDataTemplate?> TitleTemplateProperty =
+        AvaloniaProperty.Register<ContentDialog, IDataTemplate?>(nameof(TitleTemplate));
+
+    /// <summary>
+    /// Defines the <see cref="FullSizeDesired"/> property
+    /// </summary>
+    public static readonly StyledProperty<bool> FullSizeDesiredProperty =
+        AvaloniaProperty.Register<ContentDialog, bool>(nameof(FullSizeDesired));
+
+    /// <summary>
+    /// Gets or sets the command to invoke when the close button is tapped.
+    /// </summary>
+    public ICommand? CloseButtonCommand
+    {
+        get
+        {
+            return GetValue(CloseButtonCommandProperty);
+        }
+        set
+        {
+            SetValue(CloseButtonCommandProperty, value);
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets the parameter to pass to the command for the close button.
+    /// </summary>
+    public object? CloseButtonCommandParameter
+    {
+        get
+        {
+            return GetValue(CloseButtonCommandParameterProperty);
+        }
+        set
+        {
+            SetValue(CloseButtonCommandParameterProperty, value);
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets the text to display on the close button.
+    /// </summary>
+    public string? CloseButtonText
+    {
+        get
+        {
+            return GetValue(CloseButtonTextProperty);
+        }
+        set
+        {
+            SetValue(CloseButtonTextProperty, value);
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets a value that indicates which button on the dialog is the default action.
+    /// </summary>
+    public ContentDialogButton DefaultButton
+    {
+        get
+        {
+            return GetValue(DefaultButtonProperty);
+        }
+        set
+        {
+            SetValue(DefaultButtonProperty, value);
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets whether the dialog's primary button is enabled.
+    /// </summary>
+    public bool IsPrimaryButtonEnabled
+    {
+        get
+        {
+            return GetValue(IsPrimaryButtonEnabledProperty);
+        }
+        set
+        {
+            SetValue(IsPrimaryButtonEnabledProperty, value);
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets whether the dialog's secondary button is enabled.
+    /// </summary>
+    public bool IsSecondaryButtonEnabled
+    {
+        get
+        {
+            return GetValue(IsSecondaryButtonEnabledProperty);
+        }
+        set
+        {
+            SetValue(IsSecondaryButtonEnabledProperty, value);
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets the command to invoke when the primary button is tapped.
+    /// </summary>
+    public ICommand? PrimaryButtonCommand
+    {
+        get
+        {
+            return GetValue(PrimaryButtonCommandProperty);
+        }
+        set
+        {
+            SetValue(PrimaryButtonCommandProperty, value);
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets the parameter to pass to the command for the primary button.
+    /// </summary>
+    public object? PrimaryButtonCommandParameter
+    {
+        get
+        {
+            return GetValue(PrimaryButtonCommandParameterProperty);
+        }
+        set
+        {
+            SetValue(PrimaryButtonCommandParameterProperty, value);
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets the text to display on the primary button.
+    /// </summary>
+    public string? PrimaryButtonText
+    {
+        get
+        {
+            return GetValue(PrimaryButtonTextProperty);
+        }
+        set
+        {
+            SetValue(PrimaryButtonTextProperty, value);
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets the command to invoke when the secondary button is tapped.
+    /// </summary>
+    public ICommand? SecondaryButtonCommand
+    {
+        get
+        {
+            return GetValue(SecondaryButtonCommandProperty);
+        }
+        set
+        {
+            SetValue(SecondaryButtonCommandProperty, value);
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets the parameter to pass to the command for the secondary button.
+    /// </summary>
+    public object? SecondaryButtonCommandParameter
+    {
+        get
+        {
+            return GetValue(SecondaryButtonCommandParameterProperty);
+        }
+        set
+        {
+            SetValue(SecondaryButtonCommandParameterProperty, value);
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets the text to be displayed on the secondary button.
+    /// </summary>
+    public string? SecondaryButtonText
+    {
+        get
+        {
+            return GetValue(SecondaryButtonTextProperty);
+        }
+        set
+        {
+            SetValue(SecondaryButtonTextProperty, value);
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets the title of the dialog.
+    /// </summary>
+    public object? Title
+    {
+        get
+        {
+            return GetValue(TitleProperty);
+        }
+        set
+        {
+            SetValue(TitleProperty, value);
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets the title template.
+    /// </summary>
+    public IDataTemplate? TitleTemplate
+    {
+        get
+        {
+            return GetValue(TitleTemplateProperty);
+        }
+        set
+        {
+            SetValue(TitleTemplateProperty, value);
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets whether the Dialog should show full screen
+    /// On WinUI3, at least desktop, this just show the dialog at 
+    /// the maximum size of a contentdialog.
+    /// </summary>
+    public bool FullSizeDesired
+    {
+        get => GetValue(FullSizeDesiredProperty);
+        set => SetValue(FullSizeDesiredProperty, value);
+    }
+
+    /// <summary>
+    /// Occurs before the dialog is opened
+    /// </summary>
+    public event EventHandler<EventArgs>? Opening;
+
+    /// <summary>
+    /// Occurs after the dialog is opened.
+    /// </summary>
+    public event EventHandler<EventArgs>? Opened;
+
+    /// <summary>
+    /// Occurs after the dialog starts to close, but before it is closed and before the Closed event occurs.
+    /// </summary>
+    public event EventHandler<ContentDialogClosingEventArgs>? Closing;
+
+    /// <summary>
+    /// Occurs after the dialog is closed.
+    /// </summary>
+    public event EventHandler<ContentDialogClosedEventArgs>? Closed;
+
+    /// <summary>
+    /// Occurs after the primary button has been tapped.
+    /// </summary>
+    public event EventHandler<ContentDialogButtonClickEventArgs>? PrimaryButtonClick;
+
+    /// <summary>
+    /// Occurs after the secondary button has been tapped.
+    /// </summary>
+    public event EventHandler<ContentDialogButtonClickEventArgs>? SecondaryButtonClick;
+
+    /// <summary>
+    /// Occurs after the close button has been tapped.
+    /// </summary>
+    public event EventHandler<ContentDialogButtonClickEventArgs>? CloseButtonClick;
+
+
+    private const string s_tpPrimaryButton = "PrimaryButton";
+    private const string s_tpSecondaryButton = "SecondaryButton";
+    private const string s_tpCloseButton = "CloseButton";
+
+    private const string s_pcPrimary = ":primary";
+    private const string s_pcSecondary = ":secondary";
+    private const string s_pcClose = ":close";
+    private const string s_pcFullSize = ":fullsize";
+}
diff --git a/src/Avalonia.Labs.Controls/ContentDialog/ContentDialogButton.cs b/src/Avalonia.Labs.Controls/ContentDialog/ContentDialogButton.cs
new file mode 100644
index 0000000..4fc95b0
--- /dev/null
+++ b/src/Avalonia.Labs.Controls/ContentDialog/ContentDialogButton.cs
@@ -0,0 +1,28 @@
+namespace Avalonia.Labs.Controls;
+
+
+/// <summary>
+/// Defines constants that specify the default button on a content dialog.
+/// </summary>
+public enum ContentDialogButton
+{
+    /// <summary>
+    /// No button is specified as the default.
+    /// </summary>
+    None = 0,
+
+    /// <summary>
+    /// The primary button is the default.
+    /// </summary>
+    Primary = 1,
+
+    /// <summary>
+    /// The secondary button is the default.
+    /// </summary>
+    Secondary = 2,
+
+    /// <summary>
+    /// The close button is the default.
+    /// </summary>
+    Close = 3
+}
diff --git a/src/Avalonia.Labs.Controls/ContentDialog/ContentDialogPlacement.cs b/src/Avalonia.Labs.Controls/ContentDialog/ContentDialogPlacement.cs
new file mode 100644
index 0000000..a28f5c7
--- /dev/null
+++ b/src/Avalonia.Labs.Controls/ContentDialog/ContentDialogPlacement.cs
@@ -0,0 +1,18 @@
+namespace Avalonia.Labs.Controls;
+
+/// <summary>
+/// Defines constants that specify where in the XAML visual tree a ContentDialog is rooted.
+/// </summary>
+public enum ContentDialogPlacement
+{
+    /// <summary>
+    /// Place in the XamlRoot of the Window above all content. A "light dismiss" layer 
+    /// appears below.
+    /// </summary>
+    Popup = 0,
+
+    /// <summary>
+    /// Rooted in a parent container - currently not supported
+    /// </summary>
+    InPlace = 1
+}
diff --git a/src/Avalonia.Labs.Controls/ContentDialog/ContentDialogResult.cs b/src/Avalonia.Labs.Controls/ContentDialog/ContentDialogResult.cs
new file mode 100644
index 0000000..2c5a60b
--- /dev/null
+++ b/src/Avalonia.Labs.Controls/ContentDialog/ContentDialogResult.cs
@@ -0,0 +1,22 @@
+namespace Avalonia.Labs.Controls;
+
+/// <summary>
+/// Specifies identifiers to indicate the return value of a ContentDialog
+/// </summary>
+public enum ContentDialogResult
+{
+    /// <summary>
+    /// No button was tapped.
+    /// </summary>
+    None = 0,
+
+    /// <summary>
+    /// The primary button was tapped by the user.
+    /// </summary>
+    Primary = 1,
+
+    /// <summary>
+    /// The secondary button was tapped by the user.
+    /// </summary>
+    Secondary = 2
+}
diff --git a/src/Avalonia.Labs.Controls/ContentDialog/EventArgs/ContentDialogButtonClickEventArgs.cs b/src/Avalonia.Labs.Controls/ContentDialog/EventArgs/ContentDialogButtonClickEventArgs.cs
new file mode 100644
index 0000000..be6243f
--- /dev/null
+++ b/src/Avalonia.Labs.Controls/ContentDialog/EventArgs/ContentDialogButtonClickEventArgs.cs
@@ -0,0 +1,58 @@
+using System;
+using Avalonia.Threading;
+
+namespace Avalonia.Labs.Controls;
+
+/// <summary>
+/// Provides data for the button click events.
+/// </summary>
+public class ContentDialogButtonClickEventArgs : EventArgs
+{
+    internal ContentDialogButtonClickEventArgs()
+    {
+
+    }
+
+    /// <summary>
+    /// Gets or sets a value that can cancel the button click. 
+    /// A true value for Cancel cancels the default behavior.
+    /// </summary>
+    public bool Cancel { get; set; }
+
+    /// <summary>
+    /// Gets a <see cref="Deferral"/> that the app can use to 
+    /// respond asynchronously to the closing event.
+    /// </summary>
+    public Deferral GetDeferral()
+    {
+        _deferralCount++;
+
+        return new Deferral(() =>
+        {
+            Dispatcher.UIThread.VerifyAccess();
+            DecrementDeferralCount();
+        });
+    }
+
+    internal void SetDeferral(Deferral deferral)
+    {
+        _deferral = deferral;
+    }
+
+    internal void IncrementDeferralCount()
+    {
+        _deferralCount++;
+    }
+
+    internal void DecrementDeferralCount()
+    {
+        _deferralCount--;
+        if (_deferralCount == 0)
+        {
+            _deferral?.Complete();
+        }
+    }
+
+    private Deferral? _deferral;
+    private int _deferralCount;
+}
diff --git a/src/Avalonia.Labs.Controls/ContentDialog/EventArgs/ContentDialogClosedEventArgs.cs b/src/Avalonia.Labs.Controls/ContentDialog/EventArgs/ContentDialogClosedEventArgs.cs
new file mode 100644
index 0000000..e69b8cf
--- /dev/null
+++ b/src/Avalonia.Labs.Controls/ContentDialog/EventArgs/ContentDialogClosedEventArgs.cs
@@ -0,0 +1,20 @@
+using System;
+
+namespace Avalonia.Labs.Controls;
+
+/// <summary>
+/// Provides data for the Closed event.
+/// </summary>
+public class ContentDialogClosedEventArgs : EventArgs
+{
+    /// <summary>
+    /// Gets the <see cref="ContentDialogResult"/> of the button click event.
+    /// </summary>
+    public ContentDialogResult Result { get; }
+
+    internal ContentDialogClosedEventArgs(ContentDialogResult res)
+    {
+        Result = res;
+    }
+}
+
diff --git a/src/Avalonia.Labs.Controls/ContentDialog/EventArgs/ContentDialogClosingEventArgs.cs b/src/Avalonia.Labs.Controls/ContentDialog/EventArgs/ContentDialogClosingEventArgs.cs
new file mode 100644
index 0000000..45180ab
--- /dev/null
+++ b/src/Avalonia.Labs.Controls/ContentDialog/EventArgs/ContentDialogClosingEventArgs.cs
@@ -0,0 +1,63 @@
+using System;
+using Avalonia.Threading;
+
+namespace Avalonia.Labs.Controls;
+
+/// <summary>
+/// Provides data for the closing event.
+/// </summary>
+public class ContentDialogClosingEventArgs : EventArgs
+{
+    internal ContentDialogClosingEventArgs(ContentDialogResult res)
+    {
+        Result = res;
+    }
+
+    /// <summary>
+    /// Gets or sets a value that can cancel the closing of the dialog.
+    /// A true value for Cancel cancels the default behavior.
+    /// </summary>
+    public bool Cancel { get; set; }
+
+    /// <summary>
+    /// Gets the <see cref="ContentDialogResult"/> of the closing event.
+    /// </summary>
+    public ContentDialogResult Result { get; }
+
+    /// <summary>
+    /// Gets a <see cref="Deferral"/> that the app can use to 
+    /// respond asynchronously to the closing event.
+    /// </summary>
+    public Deferral GetDeferral()
+    {
+        _deferralCount++;
+
+        return new Deferral(() =>
+        {
+            Dispatcher.UIThread.VerifyAccess();
+            DecrementDeferralCount();
+        });
+    }
+
+    internal void SetDeferral(Deferral deferral)
+    {
+        _deferral = deferral;
+    }
+
+    internal void IncrementDeferralCount()
+    {
+        _deferralCount++;
+    }
+
+    internal void DecrementDeferralCount()
+    {
+        _deferralCount--;
+        if (_deferralCount == 0)
+        {
+            _deferral?.Complete();
+        }
+    }
+
+    private Deferral? _deferral;
+    private int _deferralCount;
+}
diff --git a/src/Avalonia.Labs.Controls/Deferral.cs b/src/Avalonia.Labs.Controls/Deferral.cs
new file mode 100644
index 0000000..0161344
--- /dev/null
+++ b/src/Avalonia.Labs.Controls/Deferral.cs
@@ -0,0 +1,33 @@
+using System;
+
+namespace Avalonia.Labs;
+
+/// <summary>
+/// Stores a <see cref="Action"/> to be invoked upon completion of the 
+/// deferral and manipulates the state of the deferral.
+/// </summary>
+public class Deferral
+{
+    /// <summary>
+    /// Initializes a new Deferral object and specifies a <see cref="Action"/> to be called 
+    /// upon completion of the deferral. 
+    /// </summary>
+    /// <param name="completedHandler">A <see cref="Action"/> to be called upon completion of the deferral.</param>
+    public Deferral(Action completedHandler)
+    {
+        if (completedHandler is null)
+            throw new ArgumentNullException(nameof(completedHandler), "Completion delegate cannot be null");
+
+        _handler = completedHandler;
+    }
+
+    /// <summary>
+    /// If the DeferralCompletedHandler has not yet been invoked, this will call it and drop the reference to the delegate.
+    /// </summary>
+    public void Complete()
+    {
+        _handler.Invoke();
+    }
+
+    private readonly Action _handler;
+}
diff --git a/src/Avalonia.Labs.Controls/DialogHost/DialogHost.cs b/src/Avalonia.Labs.Controls/DialogHost/DialogHost.cs
new file mode 100644
index 0000000..cb892ca
--- /dev/null
+++ b/src/Avalonia.Labs.Controls/DialogHost/DialogHost.cs
@@ -0,0 +1,101 @@
+using System;
+using Avalonia.Controls.Primitives;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Reactive;
+
+namespace Avalonia.Labs.Controls;
+
+/// <summary>
+/// Special control to host a <see cref="ContentDialog"/>/>
+/// </summary>
+/// <remarks>
+/// This class should generally not be used outside of FluentAvalonia, and is
+/// only public for Xaml styling support
+/// </remarks>
+public class DialogHost : ContentControl
+{
+    public DialogHost()
+    {
+        Background = null;
+        HorizontalAlignment = Avalonia.Layout.HorizontalAlignment.Center;
+        VerticalAlignment = Avalonia.Layout.VerticalAlignment.Center;
+    }
+
+    protected override Type StyleKeyOverride => typeof(OverlayPopupHost);
+
+    protected override Size MeasureOverride(Size availableSize)
+    {
+        _ = base.MeasureOverride(availableSize);
+
+        if (VisualRoot is TopLevel tl)
+        {
+            return tl.ClientSize;
+        }
+        else if (VisualRoot is Control c)
+        {
+            return c.Bounds.Size;
+        }
+
+        return default;
+    }
+
+    protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
+    {
+        base.OnAttachedToVisualTree(e);
+        if (e.Root is Control wb)
+        {
+            // OverlayLayer is a Canvas, so we won't get a signal to resize if the window
+            // bounds change. Subscribe to force update
+
+            var observer = new AnonymousObserver<Rect>(_ => InvalidateMeasure());
+
+            _rootBoundsWatcher = wb.GetObservable(BoundsProperty)
+                .Subscribe(observer);
+        }
+    }
+
+    protected override void OnDetachedFromVisualTree(VisualTreeAttachmentEventArgs e)
+    {
+        base.OnDetachedFromVisualTree(e);
+        _rootBoundsWatcher?.Dispose();
+        _rootBoundsWatcher = null;
+    }
+
+    protected override void OnPointerEntered(PointerEventArgs e)
+    {
+        e.Handled = true;
+    }
+
+    protected override void OnPointerExited(PointerEventArgs e)
+    {
+        e.Handled = true;
+    }
+
+    protected override void OnPointerPressed(PointerPressedEventArgs e)
+    {
+        e.Handled = true;
+    }
+
+    protected override void OnPointerReleased(PointerReleasedEventArgs e)
+    {
+        e.Handled = true;
+    }
+
+    protected override void OnPointerCaptureLost(PointerCaptureLostEventArgs e)
+    {
+        e.Handled = true;
+    }
+
+    protected override void OnPointerMoved(PointerEventArgs e)
+    {
+        e.Handled = true;
+    }
+
+    protected override void OnPointerWheelChanged(PointerWheelEventArgs e)
+    {
+        e.Handled = true;
+    }
+
+    private IDisposable? _rootBoundsWatcher;
+}
diff --git a/src/Avalonia.Labs.Controls/SharedPseudoclasses.cs b/src/Avalonia.Labs.Controls/SharedPseudoclasses.cs
new file mode 100644
index 0000000..407e743
--- /dev/null
+++ b/src/Avalonia.Labs.Controls/SharedPseudoclasses.cs
@@ -0,0 +1,12 @@
+namespace Avalonia.Labs.Controls;
+
+// These are pseudoclass names that are used in multiple controls. Share them so we don't have
+// a bunch of duplicate strings everywhere
+internal class SharedPseudoclasses
+{
+    public const string s_pcOpen = ":open";
+    public const string s_pcHidden = ":hidden";
+
+    public const string s_cAccent = "accent";
+
+}
diff --git a/src/Avalonia.Labs.Controls/Themes/Assets/Resources.xaml b/src/Avalonia.Labs.Controls/Themes/Assets/Resources.xaml
index 263abf7..ca56c6b 100644
--- a/src/Avalonia.Labs.Controls/Themes/Assets/Resources.xaml
+++ b/src/Avalonia.Labs.Controls/Themes/Assets/Resources.xaml
@@ -3,23 +3,150 @@
   <ResourceDictionary.ThemeDictionaries>
     <ResourceDictionary x:Key="Default">
 
-      <!-- Resources for NavigationControl.xaml-->
-      <x:Double x:Key="NavigationControlNavBarHeight" >45</x:Double>
-      <Thickness x:Key="NavigationControlPageMargin">0,5</Thickness>
-
-      <!-- Resources for TabControl.xaml -->
-      <Thickness x:Key="TabControlMargin">12,0,12,0</Thickness>
-      <x:Double x:Key="TabItemHeaderFontSize">24</x:Double>
-      <FontWeight x:Key="TabItemHeaderThemeFontWeight">SemiLight</FontWeight>
-      <x:Double x:Key="TabItemHeaderMinHeight">48</x:Double>
-      <x:Double x:Key="TabItemHeaderVerticalPipeHeight">24</x:Double>
-      <x:Double x:Key="TabItemHeaderPipeThickness">2</x:Double>
-      <Thickness x:Key="TabItemHeaderAdornedMargin">0,0,0,2</Thickness>
-
-      <!-- Resources for FlipView.xaml -->
-      <x:Double x:Key="FlipViewButtonFontSize">16</x:Double>
-      <x:Double x:Key="FlipViewButtonScalePressed">0.875</x:Double>
+      <Color x:Key="TextFillColorPrimary">#E4000000</Color>
+      <Color x:Key="TextFillColorSecondary">#9E000000</Color>
+      <Color x:Key="TextFillColorTertiary">#72000000</Color>
+      <Color x:Key="TextFillColorDisabled">#5C000000</Color>
+      <Color x:Key="TextFillColorInverse">#FFFFFF</Color>
+
+      <Color x:Key="CardStrokeColorDefault">#0F000000</Color>
+      <Color x:Key="CardStrokeColorDefaultSolid">#EBEBEB</Color>
+
+      <Color x:Key="LayerFillColorAlt">#FFFFFF</Color>
+
+      <Color x:Key="SmokeFillColorDefault">#4D000000</Color>
+
+      <Color x:Key="SolidBackgroundFillColorBase">#F3F3F3</Color>
+      <Color x:Key="SolidBackgroundFillColorSecondary">#EEEEEE</Color>
+      <Color x:Key="SolidBackgroundFillColorTertiary">#F9F9F9</Color>
+      <Color x:Key="SolidBackgroundFillColorQuarternary">#FFFFFF</Color>
+      <Color x:Key="SolidBackgroundFillColorTransparent">#00F3F3F3</Color>
+
+      <Color x:Key="SurfaceStrokeColorDefault">#66757575</Color>
+      <Color x:Key="SurfaceStrokeColorFlyout">#0F000000</Color>
+      <Color x:Key="SurfaceStrokeColorInverse">#15FFFFFF</Color>
+
+      <SolidColorBrush x:Key="CardStrokeColorDefaultBrush" Color="{StaticResource CardStrokeColorDefault}" />
+      <SolidColorBrush x:Key="CardStrokeColorDefaultSolidBrush" Color="{StaticResource CardStrokeColorDefaultSolid}" />
+
+      <SolidColorBrush x:Key="TextFillColorPrimaryBrush" Color="{StaticResource TextFillColorPrimary}" />
+      <SolidColorBrush x:Key="TextFillColorSecondaryBrush" Color="{StaticResource TextFillColorSecondary}" />
+      <SolidColorBrush x:Key="TextFillColorTertiaryBrush" Color="{StaticResource TextFillColorTertiary}" />
+      <SolidColorBrush x:Key="TextFillColorDisabledBrush" Color="{StaticResource TextFillColorDisabled}" />
+      <SolidColorBrush x:Key="TextFillColorInverseBrush" Color="{StaticResource TextFillColorInverse}" />
+
+      <SolidColorBrush x:Key="LayerFillColorAltBrush" Color="{StaticResource LayerFillColorAlt}" />
+
+      <SolidColorBrush x:Key="SmokeFillColorDefaultBrush" Color="{StaticResource SmokeFillColorDefault}" />
+
+      <SolidColorBrush x:Key="SolidBackgroundFillColorBaseBrush" Color="{StaticResource SolidBackgroundFillColorBase}" />
+      <SolidColorBrush x:Key="SolidBackgroundFillColorSecondaryBrush" Color="{StaticResource SolidBackgroundFillColorSecondary}" />
+      <SolidColorBrush x:Key="SolidBackgroundFillColorTertiaryBrush" Color="{StaticResource SolidBackgroundFillColorTertiary}" />
+      <SolidColorBrush x:Key="SolidBackgroundFillColorQuarternaryBrush" Color="{StaticResource SolidBackgroundFillColorQuarternary}" />
+
+      <SolidColorBrush x:Key="SurfaceStrokeColorDefaultBrush" Color="{StaticResource SurfaceStrokeColorDefault}" />
+      <SolidColorBrush x:Key="SurfaceStrokeColorFlyoutBrush" Color="{StaticResource SurfaceStrokeColorFlyout}" />
+      <SolidColorBrush x:Key="SurfaceStrokeColorInverseBrush" Color="{StaticResource SurfaceStrokeColorInverse}" />
+
+      <!-- CONTENT DIALOG -->
+      <StaticResource x:Key="ContentDialogForeground" ResourceKey="TextFillColorPrimaryBrush" />
+      <StaticResource x:Key="ContentDialogBackground" ResourceKey="SolidBackgroundFillColorBaseBrush" />
+      <StaticResource x:Key="ContentDialogSmokeFill" ResourceKey="SmokeFillColorDefaultBrush" />
+      <StaticResource x:Key="ContentDialogTopOverlay" ResourceKey="LayerFillColorAltBrush" />
+      <StaticResource x:Key="ContentDialogBorderBrush" ResourceKey="SurfaceStrokeColorDefaultBrush" />
+      <StaticResource x:Key="ContentDialogSeparatorBorderBrush" ResourceKey="CardStrokeColorDefaultBrush" />
+
+    </ResourceDictionary>
+
+    <ResourceDictionary x:Key="Dark">
+
+      <Color x:Key="TextFillColorPrimary">#FFFFFF</Color>
+      <Color x:Key="TextFillColorSecondary">#C5FFFFFF</Color>
+      <Color x:Key="TextFillColorTertiary">#87FFFFFF</Color>
+      <Color x:Key="TextFillColorDisabled">#5DFFFFFF</Color>
+      <Color x:Key="TextFillColorInverse">#E4000000</Color>
+
+      <Color x:Key="CardStrokeColorDefault">#19000000</Color>
+      <Color x:Key="CardStrokeColorDefaultSolid">#1C1C1C</Color>
+
+      <Color x:Key="LayerFillColorAlt">#0DFFFFFF</Color>
+
+      <Color x:Key="SmokeFillColorDefault">#4D000000</Color>
+
+      <Color x:Key="SolidBackgroundFillColorBase">#202020</Color>
+      <Color x:Key="SolidBackgroundFillColorSecondary">#1C1C1C</Color>
+      <Color x:Key="SolidBackgroundFillColorTertiary">#282828</Color>
+      <Color x:Key="SolidBackgroundFillColorQuarternary">#2C2C2C</Color>
+      <Color x:Key="SolidBackgroundFillColorTransparent">#00202020</Color>
+
+      <Color x:Key="SurfaceStrokeColorDefault">#66757575</Color>
+      <Color x:Key="SurfaceStrokeColorFlyout">#33000000</Color>
+      <Color x:Key="SurfaceStrokeColorInverse">#0F000000</Color>
+
+      <SolidColorBrush x:Key="CardStrokeColorDefaultBrush" Color="{StaticResource CardStrokeColorDefault}" />
+      <SolidColorBrush x:Key="CardStrokeColorDefaultSolidBrush" Color="{StaticResource CardStrokeColorDefaultSolid}" />
+
+      <SolidColorBrush x:Key="TextFillColorPrimaryBrush" Color="{StaticResource TextFillColorPrimary}" />
+      <SolidColorBrush x:Key="TextFillColorSecondaryBrush" Color="{StaticResource TextFillColorSecondary}" />
+      <SolidColorBrush x:Key="TextFillColorTertiaryBrush" Color="{StaticResource TextFillColorTertiary}" />
+      <SolidColorBrush x:Key="TextFillColorDisabledBrush" Color="{StaticResource TextFillColorDisabled}" />
+      <SolidColorBrush x:Key="TextFillColorInverseBrush" Color="{StaticResource TextFillColorInverse}" />
+
+      <SolidColorBrush x:Key="LayerFillColorAltBrush" Color="{StaticResource LayerFillColorAlt}" />
+
+      <SolidColorBrush x:Key="SmokeFillColorDefaultBrush" Color="{StaticResource SmokeFillColorDefault}" />
+
+      <SolidColorBrush x:Key="SolidBackgroundFillColorBaseBrush" Color="{StaticResource SolidBackgroundFillColorBase}" />
+      <SolidColorBrush x:Key="SolidBackgroundFillColorSecondaryBrush" Color="{StaticResource SolidBackgroundFillColorSecondary}" />
+      <SolidColorBrush x:Key="SolidBackgroundFillColorTertiaryBrush" Color="{StaticResource SolidBackgroundFillColorTertiary}" />
+      <SolidColorBrush x:Key="SolidBackgroundFillColorQuarternaryBrush" Color="{StaticResource SolidBackgroundFillColorQuarternary}" />
+
+      <SolidColorBrush x:Key="SurfaceStrokeColorDefaultBrush" Color="{StaticResource SurfaceStrokeColorDefault}" />
+      <SolidColorBrush x:Key="SurfaceStrokeColorFlyoutBrush" Color="{StaticResource SurfaceStrokeColorFlyout}" />
+      <SolidColorBrush x:Key="SurfaceStrokeColorInverseBrush" Color="{StaticResource SurfaceStrokeColorInverse}" />
+
+      <!-- CONTENT DIALOG -->
+      <StaticResource x:Key="ContentDialogForeground" ResourceKey="TextFillColorPrimaryBrush" />
+      <StaticResource x:Key="ContentDialogBackground" ResourceKey="SolidBackgroundFillColorBaseBrush" />
+      <StaticResource x:Key="ContentDialogSmokeFill" ResourceKey="SmokeFillColorDefaultBrush" />
+      <StaticResource x:Key="ContentDialogTopOverlay" ResourceKey="LayerFillColorAltBrush" />
+      <StaticResource x:Key="ContentDialogBorderBrush" ResourceKey="SurfaceStrokeColorDefaultBrush" />
+      <StaticResource x:Key="ContentDialogSeparatorBorderBrush" ResourceKey="CardStrokeColorDefaultBrush" />
 
     </ResourceDictionary>
   </ResourceDictionary.ThemeDictionaries>
+
+
+  
+  
+  <!-- Resources for NavigationControl.xaml-->
+  <x:Double x:Key="NavigationControlNavBarHeight" >45</x:Double>
+  <Thickness x:Key="NavigationControlPageMargin">0,5</Thickness>
+
+  <!-- Resources for TabControl.xaml -->
+  <Thickness x:Key="TabControlMargin">12,0,12,0</Thickness>
+  <x:Double x:Key="TabItemHeaderFontSize">24</x:Double>
+  <FontWeight x:Key="TabItemHeaderThemeFontWeight">SemiLight</FontWeight>
+  <x:Double x:Key="TabItemHeaderMinHeight">48</x:Double>
+  <x:Double x:Key="TabItemHeaderVerticalPipeHeight">24</x:Double>
+  <x:Double x:Key="TabItemHeaderPipeThickness">2</x:Double>
+  <Thickness x:Key="TabItemHeaderAdornedMargin">0,0,0,2</Thickness>
+
+  <!-- Resources for FlipView.xaml -->
+  <x:Double x:Key="FlipViewButtonFontSize">16</x:Double>
+  <x:Double x:Key="FlipViewButtonScalePressed">0.875</x:Double>
+
+
+  <Thickness x:Key="ContentDialogBorderWidth">1</Thickness>
+
+  <x:Double x:Key="ContentDialogMinWidth">320</x:Double>
+  <x:Double x:Key="ContentDialogMaxWidth">548</x:Double>
+  <x:Double x:Key="ContentDialogMinHeight">184</x:Double>
+  <x:Double x:Key="ContentDialogMaxHeight">756</x:Double>
+
+  <!-- See ContentDialog.xaml for why this was changed to double -->
+  <x:Double x:Key="ContentDialogButtonSpacing">8</x:Double>
+  <Thickness x:Key="ContentDialogTitleMargin">0,0,0,12</Thickness>
+  <Thickness x:Key="ContentDialogPadding">24</Thickness>
+  <Thickness x:Key="ContentDialogSeparatorThickness">0,0,0,1</Thickness>
 </ResourceDictionary>
diff --git a/src/Avalonia.Labs.Controls/Themes/Controls/ContentDialog.axaml b/src/Avalonia.Labs.Controls/Themes/Controls/ContentDialog.axaml
new file mode 100644
index 0000000..5cd9e83
--- /dev/null
+++ b/src/Avalonia.Labs.Controls/Themes/Controls/ContentDialog.axaml
@@ -0,0 +1,352 @@
+<ResourceDictionary xmlns="https://github.com/avaloniaui"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                    xmlns:ui="clr-namespace:Avalonia.Labs.Controls"
+                    x:CompileBindings="True">
+  <Design.PreviewWith>
+    <Border Padding="50">
+      <ui:ContentDialog Title="Title"
+                        Content="Content goes here"
+                        />
+    </Border>
+  </Design.PreviewWith>
+
+  <ControlTheme x:Key="{x:Type ui:ContentDialog}" TargetType="ui:ContentDialog">
+    <Setter Property="Foreground" Value="{DynamicResource ContentDialogForeground}"/>
+    <Setter Property="Background" Value="{DynamicResource ContentDialogBackground}"/>
+    <Setter Property="BorderBrush" Value="{DynamicResource ContentDialogBorderBrush}"/>
+    <Setter Property="BorderThickness" Value="{DynamicResource ContentDialogBorderWidth}" />
+    <Setter Property="CornerRadius" Value="{DynamicResource OverlayCornerRadius}" />
+    <Setter Property="Template">
+      <ControlTemplate>
+        <Border Name="Container">
+          <Panel Name="LayoutRoot"
+                 Background="{DynamicResource ContentDialogSmokeFill}">
+            <Border Name="BackgroundElement"
+                    Background="{TemplateBinding Background}"
+                    BorderThickness="{StaticResource ContentDialogBorderWidth}"
+                    BorderBrush="{TemplateBinding BorderBrush}"
+                    CornerRadius="{TemplateBinding CornerRadius}"
+                    MinWidth="{DynamicResource ContentDialogMinWidth}"
+                    MaxWidth="{DynamicResource ContentDialogMaxWidth}"
+                    MinHeight="{DynamicResource ContentDialogMinHeight}"
+                    MaxHeight="{DynamicResource ContentDialogMaxHeight}"
+                    HorizontalAlignment="Center"
+                    VerticalAlignment="Center"
+                    BoxShadow="0 8 32 0 #66000000" >
+              <!-- Even in WinUI, shadow is always black regardless of light/dark mode -->
+
+              <!-- if this border isn't here, dialog space displays outside of corner radius at top
+                                 if we put ClipToBounds=True on BackgroundElement above, it clips the shadow -->
+              <Border ClipToBounds="True"
+                      CornerRadius="{TemplateBinding CornerRadius}">
+                <Grid Name="DialogSpace" ClipToBounds="True"
+                  RowDefinitions="*,Auto">
+                  <ScrollViewer Name="ContentScrollViewer"
+                                HorizontalScrollBarVisibility="Disabled"
+                                VerticalScrollBarVisibility="Auto">
+                    <Border Background="{DynamicResource ContentDialogTopOverlay}"
+                            Padding="{DynamicResource ContentDialogPadding}"
+                            BorderThickness="{StaticResource ContentDialogSeparatorThickness}"
+                            BorderBrush="{DynamicResource ContentDialogSeparatorBorderBrush}">
+                      <Grid RowDefinitions="Auto,*" >
+                        <Grid.Styles>
+                          <!--Make sure text wrapping is on-->
+                          <Style Selector="TextBlock">
+                            <Setter Property="TextWrapping" Value="Wrap"/>
+                          </Style>
+                        </Grid.Styles>
+                        <ContentControl Name="Title"
+                                        Margin="{StaticResource ContentDialogTitleMargin}"
+                                        Content="{TemplateBinding Title}"
+                                        ContentTemplate="{TemplateBinding TitleTemplate}"
+                                        FontSize="20"
+                                        FontFamily="Default"
+                                        FontWeight="SemiBold"
+                                        Foreground="{TemplateBinding Foreground}"
+                                        HorizontalAlignment="Left"
+                                        VerticalAlignment="Top">
+                          <ContentControl.Template>
+                            <ControlTemplate>
+                              <ContentPresenter Content="{TemplateBinding Content}"
+                                                ContentTemplate="{TemplateBinding ContentTemplate}"
+                                                Margin="{TemplateBinding Padding}"
+                                                HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
+                                                VerticalAlignment="{TemplateBinding VerticalContentAlignment}"/>
+                            </ControlTemplate>
+                          </ContentControl.Template>
+                        </ContentControl>
+
+                        <ContentPresenter Name="Content"
+                                          ContentTemplate="{TemplateBinding ContentTemplate}"
+                                          Content="{TemplateBinding Content}"
+                                          FontSize="{StaticResource ControlContentThemeFontSize}"
+                                          FontFamily="{StaticResource ContentControlThemeFontFamily}"
+                                          Foreground="{TemplateBinding Foreground}"
+                                          Grid.Row="1"/>
+                      </Grid>
+                    </Border>
+                  </ScrollViewer>
+
+                  <Border Padding="{StaticResource ContentDialogPadding}"
+                          Grid.Row="1"
+                          HorizontalAlignment="Stretch"
+                          VerticalAlignment="Bottom"
+                          Background="{TemplateBinding Background}">
+                    <Grid Name="CommandSpace">
+                      <!--
+                                            B/C we can't target Row/Column defs in Styles like WinUI
+                                            this still uses the old Col defs, but it works the same
+                                            way in the end...
+                                            -->
+                      <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="*" />
+                        <ColumnDefinition Width="0.5*" />
+                        <ColumnDefinition Width="0.5*" />
+                        <ColumnDefinition Width="*" />
+                      </Grid.ColumnDefinitions>
+                      <Button Name="PrimaryButton"
+                              Content="{TemplateBinding PrimaryButtonText}"
+                              IsEnabled="{TemplateBinding IsPrimaryButtonEnabled}"
+                              Command="{TemplateBinding PrimaryButtonCommand}"
+                              CommandParameter="{TemplateBinding PrimaryButtonCommandParameter}"
+                              HorizontalAlignment="Stretch"
+                              VerticalAlignment="Stretch"
+                              HorizontalContentAlignment="Center"
+                              VerticalContentAlignment="Center"
+                              IsVisible="False" />
+
+                      <Button Name="SecondaryButton"
+                              Content="{TemplateBinding SecondaryButtonText}"
+                              IsEnabled="{TemplateBinding IsSecondaryButtonEnabled}"
+                              Command="{TemplateBinding SecondaryButtonCommand}"
+                              CommandParameter="{TemplateBinding SecondaryButtonCommandParameter}"
+                              HorizontalAlignment="Stretch" VerticalAlignment="Stretch"
+                              HorizontalContentAlignment="Center"
+                              VerticalContentAlignment="Center"
+                              IsVisible="False"  />
+
+                      <Button Name="CloseButton"
+                              Content="{TemplateBinding CloseButtonText}"
+                              Command="{TemplateBinding CloseButtonCommand}"
+                              CommandParameter="{TemplateBinding CloseButtonCommandParameter}"
+                              HorizontalAlignment="Stretch"
+                              VerticalAlignment="Stretch"
+                              HorizontalContentAlignment="Center"
+                              VerticalContentAlignment="Center"
+                              IsVisible="False" />
+                    </Grid>
+                  </Border>
+                </Grid>
+              </Border>
+            </Border>
+          </Panel>
+        </Border>
+      </ControlTemplate>
+    </Setter>
+
+    <!--Handle hidden dialog-->
+    <Style Selector="^:hidden /template/ Panel#LayoutRoot">
+      <Style.Animations>
+        <Animation Duration="00:00:00.167" FillMode="Forward">
+          <KeyFrame Cue="0%">
+            <Setter Property="Opacity" Value="1.0"/>
+          </KeyFrame>
+          <KeyFrame Cue="100%">
+            <Setter Property="Opacity" Value="0.0"/>
+            <Setter Property="IsVisible" Value="False" />
+          </KeyFrame>
+        </Animation>
+      </Style.Animations>
+    </Style>
+    <Style Selector="^:hidden /template/ Border#Container">
+      <Style.Animations>
+        <Animation Duration="00:00:00.167" FillMode="Forward">
+          <KeyFrame Cue="0%">
+            <Setter Property="ScaleTransform.ScaleX" Value="1.0"/>
+            <Setter Property="ScaleTransform.ScaleY" Value="1.0"/>
+          </KeyFrame>
+          <KeyFrame Cue="100%" KeySpline="0,0 0,1">
+            <Setter Property="ScaleTransform.ScaleX" Value="1.05"/>
+            <Setter Property="ScaleTransform.ScaleY" Value="1.05"/>
+          </KeyFrame>
+        </Animation>
+      </Style.Animations>
+    </Style>
+
+    <!--Handle open dialog-->
+    <Style Selector="^:open /template/ Panel#LayoutRoot">
+      <Setter Property="IsVisible" Value="True"/>
+      <Style.Animations>
+        <!--Animation applies with priority of LocalValue
+                 To overrule the IsVisible=False in :hidden, set
+                 IsVisible=True in BOTH KeyFrames here-->
+        <Animation Duration="00:00:00.250" FillMode="Forward">
+          <KeyFrame Cue="0%">
+            <Setter Property="IsVisible" Value="True"/>
+            <Setter Property="Opacity" Value="0.0"/>
+          </KeyFrame>
+          <KeyFrame Cue="100%">
+            <Setter Property="IsVisible" Value="True"/>
+            <Setter Property="Opacity" Value="1.0"/>
+          </KeyFrame>
+        </Animation>
+      </Style.Animations>
+    </Style>
+    <Style Selector="^:open /template/ Border#Container">
+      <Style.Animations>
+        <Animation Duration="00:00:00.250" FillMode="Forward">
+          <KeyFrame Cue="0%">
+            <Setter Property="ScaleTransform.ScaleX" Value="1.05"/>
+            <Setter Property="ScaleTransform.ScaleY" Value="1.05"/>
+          </KeyFrame>
+          <KeyFrame Cue="100%" KeySpline="0,0 0,1">
+            <Setter Property="ScaleTransform.ScaleX" Value="1.00"/>
+            <Setter Property="ScaleTransform.ScaleY" Value="1.00"/>
+          </KeyFrame>
+        </Animation>
+      </Style.Animations>
+    </Style>
+
+    <!--Handle showing smoke layer-->
+    <Style Selector="^:nosmokelayer /template/ Panel#LayoutRoot">
+      <Setter Property="Background" Value="{x:Null}"/>
+    </Style>
+
+    <!--Handle FullDialogSizing-->
+    <Style Selector="^:fullsize /template/ Border#BackgroundElement">
+      <Setter Property="VerticalAlignment" Value="Stretch"/>
+    </Style>
+
+
+    <!-- Primary Button Only -->
+    <Style Selector="^:primary /template/ Button#PrimaryButton">
+      <Setter Property="IsVisible" Value="True"/>
+      <Setter Property="Grid.Column" Value="2" />
+      <Setter Property="Grid.ColumnSpan" Value="2" />
+    </Style>
+    <Style Selector="^:primary /template/ Button#SecondaryButton">
+      <Setter Property="IsVisible" Value="False"/>
+    </Style>
+    <Style Selector="^:primary /template/ Button#CloseButton">
+      <Setter Property="IsVisible" Value="False"/>
+    </Style>
+
+    <!-- Secondary Button Only -->
+    <Style Selector="^:secondary /template/ Button#PrimaryButton">
+      <Setter Property="IsVisible" Value="False"/>
+    </Style>
+    <Style Selector="^:secondary /template/ Button#SecondaryButton">
+      <Setter Property="IsVisible" Value="True"/>
+      <Setter Property="Grid.Column" Value="2" />
+      <Setter Property="Grid.ColumnSpan" Value="2" />
+    </Style>
+    <Style Selector="^:secondary /template/ Button#CloseButton">
+      <Setter Property="IsVisible" Value="False"/>
+    </Style>
+
+    <!-- Close Button Only -->
+    <Style Selector="^:close /template/ Button#PrimaryButton">
+      <Setter Property="IsVisible" Value="False"/>
+    </Style>
+    <Style Selector="^:close /template/ Button#SecondaryButton">
+      <Setter Property="IsVisible" Value="False"/>
+    </Style>
+    <Style Selector="^:close /template/ Button#CloseButton">
+      <Setter Property="IsVisible" Value="True"/>
+      <Setter Property="Grid.Column" Value="2" />
+      <Setter Property="Grid.ColumnSpan" Value="2" />
+    </Style>
+
+    <!-- Margins are defined by ContentDialogButtonSpacing (8) -->
+
+    <!-- Primary and Secondary -->
+    <Style Selector="^:primary:secondary /template/ Button#PrimaryButton">
+      <Setter Property="IsVisible" Value="True"/>
+      <Setter Property="Grid.Column" Value="0" />
+      <Setter Property="Grid.ColumnSpan" Value="2" />
+      <Setter Property="Margin" Value="0 0 4 0" />
+    </Style>
+    <Style Selector="^:primary:secondary /template/ Button#SecondaryButton">
+      <Setter Property="IsVisible" Value="True"/>
+      <Setter Property="Grid.Column" Value="2" />
+      <Setter Property="Grid.ColumnSpan" Value="2" />
+      <Setter Property="Margin" Value="4 0 0 0" />
+    </Style>
+    <Style Selector="^:primary:secondary /template/ Button#CloseButton">
+      <Setter Property="IsVisible" Value="False"/>
+    </Style>
+
+    <!-- Primary and Close Buttons -->
+    <Style Selector="^:primary:close /template/ Button#PrimaryButton">
+      <Setter Property="IsVisible" Value="True"/>
+      <Setter Property="Grid.Column" Value="0" />
+      <Setter Property="Grid.ColumnSpan" Value="2" />
+      <Setter Property="Margin" Value="0 0 4 0" />
+    </Style>
+    <Style Selector="^:primary:close /template/ Button#SecondaryButton">
+      <Setter Property="IsVisible" Value="False"/>
+    </Style>
+    <Style Selector="^:primary:close /template/ Button#CloseButton">
+      <Setter Property="IsVisible" Value="True"/>
+      <Setter Property="Grid.Column" Value="2" />
+      <Setter Property="Grid.ColumnSpan" Value="2" />
+      <Setter Property="Margin" Value="4 0 0 0" />
+    </Style>
+
+    <!-- Primary and Secondary Buttons -->
+    <Style Selector="^:primary:secondary /template/ Button#PrimaryButton">
+      <Setter Property="IsVisible" Value="True"/>
+      <Setter Property="Grid.Column" Value="0" />
+      <Setter Property="Grid.ColumnSpan" Value="2" />
+      <Setter Property="Margin" Value="0 0 4 0" />
+    </Style>
+    <Style Selector="^:primary:secondary /template/ Button#CloseButton">
+      <Setter Property="IsVisible" Value="False"/>
+    </Style>
+    <Style Selector="^:primary:secondary /template/ Button#SecondaryButton">
+      <Setter Property="IsVisible" Value="True"/>
+      <Setter Property="Grid.Column" Value="2" />
+      <Setter Property="Grid.ColumnSpan" Value="2" />
+      <Setter Property="Margin" Value="4 0 0 0" />
+    </Style>
+
+    <!-- Secondary and Close Buttons -->
+    <Style Selector="^:secondary:close /template/ Button#Secondary">
+      <Setter Property="IsVisible" Value="True"/>
+      <Setter Property="Grid.Column" Value="0" />
+      <Setter Property="Grid.ColumnSpan" Value="2" />
+      <Setter Property="Margin" Value="0 0 4 0" />
+    </Style>
+    <Style Selector="^:secondary:close /template/ Button#PrimaryButton">
+      <Setter Property="IsVisible" Value="False"/>
+    </Style>
+    <Style Selector="^:secondary:close /template/ Button#CloseButton">
+      <Setter Property="IsVisible" Value="True"/>
+      <Setter Property="Grid.Column" Value="2" />
+      <Setter Property="Grid.ColumnSpan" Value="2" />
+      <Setter Property="Margin" Value="4 0 0 0" />
+    </Style>
+
+
+    <!-- All Buttons -->
+    <Style Selector="^:primary:secondary:close /template/ Button#PrimaryButton">
+      <Setter Property="IsVisible" Value="True"/>
+      <Setter Property="Grid.Column" Value="0" />
+      <Setter Property="Grid.ColumnSpan" Value="1" />
+      <Setter Property="Margin" Value="0 0 4 0" />
+    </Style>
+    <Style Selector="^:primary:secondary:close /template/ Button#SecondaryButton">
+      <Setter Property="IsVisible" Value="True"/>
+      <Setter Property="Grid.Column" Value="1" />
+      <Setter Property="Grid.ColumnSpan" Value="2" />
+      <Setter Property="Margin" Value="4 0 4 0" />
+    </Style>
+    <Style Selector="^:primary:secondary:close /template/ Button#CloseButton">
+      <Setter Property="IsVisible" Value="True"/>
+      <Setter Property="Grid.Column" Value="3" />
+      <Setter Property="Grid.ColumnSpan" Value="1" />
+      <Setter Property="Margin" Value="4 0 0 0" />
+    </Style>
+  </ControlTheme>
+
+</ResourceDictionary>
diff --git a/src/Avalonia.Labs.Controls/Themes/Controls/Controls.xaml b/src/Avalonia.Labs.Controls/Themes/Controls/Controls.xaml
index dd92e7b..fe5f830 100644
--- a/src/Avalonia.Labs.Controls/Themes/Controls/Controls.xaml
+++ b/src/Avalonia.Labs.Controls/Themes/Controls/Controls.xaml
@@ -5,23 +5,24 @@
 
   <Styles.Resources>
     <ResourceDictionary>
-            <ResourceDictionary.MergedDictionaries>
-                <MergeResourceInclude Source="avares://Avalonia.Labs.Controls/Themes/Controls/NavigationControl.xaml" />
-                <MergeResourceInclude Source="avares://Avalonia.Labs.Controls/Themes/Controls/TabControl.xaml" />
-                <MergeResourceInclude Source="avares://Avalonia.Labs.Controls/Themes/Controls/TabItem.xaml" />
-                <MergeResourceInclude Source="avares://Avalonia.Labs.Controls/Themes/Controls/TabHeader.xaml" />
-                <MergeResourceInclude Source="avares://Avalonia.Labs.Controls/Themes/Controls/TabHeaderItem.xaml" />
-                <MergeResourceInclude Source="avares://Avalonia.Labs.Controls/Themes/Controls/FlipView.xaml" />
-                <MergeResourceInclude Source="avares://Avalonia.Labs.Controls/Themes/Controls/FlipViewItem.xaml" />
-                <MergeResourceInclude Source="avares://Avalonia.Labs.Controls/Themes/Controls/AsyncImage.xaml" />
-                <MergeResourceInclude Source="avares://Avalonia.Labs.Controls/Themes/Controls/StepBar.axaml" />
+      <ResourceDictionary.MergedDictionaries>
+        <MergeResourceInclude Source="avares://Avalonia.Labs.Controls/Themes/Controls/NavigationControl.xaml" />
+        <MergeResourceInclude Source="avares://Avalonia.Labs.Controls/Themes/Controls/TabControl.xaml" />
+        <MergeResourceInclude Source="avares://Avalonia.Labs.Controls/Themes/Controls/TabItem.xaml" />
+        <MergeResourceInclude Source="avares://Avalonia.Labs.Controls/Themes/Controls/TabHeader.xaml" />
+        <MergeResourceInclude Source="avares://Avalonia.Labs.Controls/Themes/Controls/TabHeaderItem.xaml" />
+        <MergeResourceInclude Source="avares://Avalonia.Labs.Controls/Themes/Controls/FlipView.xaml" />
+        <MergeResourceInclude Source="avares://Avalonia.Labs.Controls/Themes/Controls/FlipViewItem.xaml" />
+        <MergeResourceInclude Source="avares://Avalonia.Labs.Controls/Themes/Controls/AsyncImage.xaml" />
+        <MergeResourceInclude Source="avares://Avalonia.Labs.Controls/Themes/Controls/StepBar.axaml" />
+        <MergeResourceInclude Source="avares://Avalonia.Labs.Controls/Themes/Controls/ContentDialog.axaml" />
       </ResourceDictionary.MergedDictionaries>
-        </ResourceDictionary>
+    </ResourceDictionary>
   </Styles.Resources>
   <Style Selector="control|FlipView > control|FlipViewItem">
-      <Setter Property="Width"
-              Value="{Binding $parent.Bounds.Width}" />
-      <Setter Property="Height"
-              Value="{Binding $parent.Bounds.Height}" />
+    <Setter Property="Width"
+            Value="{Binding $parent.Bounds.Width}" />
+    <Setter Property="Height"
+            Value="{Binding $parent.Bounds.Height}" />
   </Style>
 </Styles>