diff --git a/AxialSqlTools/SchemaCompare/SchemaCompareWindowControl.xaml b/AxialSqlTools/SchemaCompare/SchemaCompareWindowControl.xaml
index 85c103c..805c466 100644
--- a/AxialSqlTools/SchemaCompare/SchemaCompareWindowControl.xaml
+++ b/AxialSqlTools/SchemaCompare/SchemaCompareWindowControl.xaml
@@ -50,14 +50,38 @@
             <TabItem Header="Differences">
                 <Grid>
                     <Grid.RowDefinitions>
+                        <RowDefinition Height="Auto" />
                         <RowDefinition Height="2*" />
                         <RowDefinition Height="3*" />
                     </Grid.RowDefinitions>
 
-                    <DataGrid Grid.Row="0" ItemsSource="{Binding Differences}" AutoGenerateColumns="False" IsReadOnly="True"
+                    <StackPanel Grid.Row="0" Margin="0,0,0,8" Orientation="Vertical">
+                        <TextBlock Text="Object types included in comparison:" FontWeight="Bold" Margin="0,0,0,4" />
+                        <ScrollViewer Height="80" VerticalScrollBarVisibility="Auto">
+                            <ItemsControl ItemsSource="{Binding ObjectTypeFilters}">
+                                <ItemsControl.ItemsPanel>
+                                    <ItemsPanelTemplate>
+                                        <WrapPanel />
+                                    </ItemsPanelTemplate>
+                                </ItemsControl.ItemsPanel>
+                                <ItemsControl.ItemTemplate>
+                                    <DataTemplate>
+                                        <CheckBox Content="{Binding DisplayName}" IsChecked="{Binding IsIncluded, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" Margin="0,0,12,4" />
+                                    </DataTemplate>
+                                </ItemsControl.ItemTemplate>
+                            </ItemsControl>
+                        </ScrollViewer>
+                        <StackPanel Orientation="Horizontal" HorizontalAlignment="Left" Margin="0,4,0,0">
+                            <Button Content="Include All" Width="120" Command="{Binding IncludeAllObjectTypesCommand}" />
+                            <Button Content="Exclude All" Width="120" Margin="8,0,0,0" Command="{Binding ExcludeAllObjectTypesCommand}" />
+                        </StackPanel>
+                    </StackPanel>
+
+                    <DataGrid Grid.Row="1" ItemsSource="{Binding Differences}" AutoGenerateColumns="False"
                               SelectedItem="{Binding SelectedDifference, Mode=TwoWay}" CanUserAddRows="False"
                               HeadersVisibility="Column" Margin="0,0,0,8">
                         <DataGrid.Columns>
+                            <DataGridCheckBoxColumn Header="Include" Binding="{Binding IsSelected, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" Width="80" IsReadOnly="False" />
                             <DataGridTextColumn Header="Name" Binding="{Binding Name}" Width="*" />
                             <DataGridTextColumn Header="Action" Binding="{Binding Action}" Width="*" />
                             <DataGridTextColumn Header="Difference Type" Binding="{Binding DifferenceType}" Width="*" />
@@ -66,7 +90,7 @@
                         </DataGrid.Columns>
                     </DataGrid>
 
-                    <Grid Grid.Row="1">
+                    <Grid Grid.Row="2">
                         <Grid.ColumnDefinitions>
                             <ColumnDefinition Width="*" />
                             <ColumnDefinition Width="*" />
@@ -216,6 +240,7 @@
                         <RowDefinition Height="*" />
                     </Grid.RowDefinitions>
                     <StackPanel Orientation="Horizontal" HorizontalAlignment="Right" Margin="0,0,0,4">
+                        <Button Content="Generate Script" Width="140" Margin="0,0,8,0" Command="{Binding GenerateDeploymentScriptCommand}" />
                         <Button Content="Copy Script" Width="120" Command="{Binding CopyDeploymentScriptCommand}" />
                     </StackPanel>
                     <TextBox Grid.Row="1" Text="{Binding DeploymentScript, Mode=OneWay}" FontFamily="Consolas" FontSize="12" AcceptsReturn="True"
diff --git a/AxialSqlTools/SchemaCompare/SchemaCompareWindowControl.xaml.cs b/AxialSqlTools/SchemaCompare/SchemaCompareWindowControl.xaml.cs
index 2522897..b31cb20 100644
--- a/AxialSqlTools/SchemaCompare/SchemaCompareWindowControl.xaml.cs
+++ b/AxialSqlTools/SchemaCompare/SchemaCompareWindowControl.xaml.cs
@@ -1,15 +1,12 @@
-using Azure.Storage.Blobs.Models;
 using DiffPlex;
 using DiffPlex.DiffBuilder;
 using DiffPlex.DiffBuilder.Model;
-using DocumentFormat.OpenXml.Drawing.Diagrams;
-using DocumentFormat.OpenXml.Math;
 using Microsoft.SqlServer.Dac.Compare;
 using System;
+using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.ComponentModel;
 using System.Linq;
-using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Text;
@@ -45,12 +42,15 @@ internal class SchemaCompareViewModel : INotifyPropertyChanged
         private string _deploymentScript = string.Empty;
         private SchemaDifferenceViewModel _selectedDifference;
         private CancellationTokenSource _cancellationTokenSource;
+        private SchemaComparisonResult _comparisonResult;
+        private string _targetDatabaseName = string.Empty;
 
         public SchemaCompareViewModel()
         {
             Differences = new ObservableCollection<SchemaDifferenceViewModel>();
             SourceDiffLines = new ObservableCollection<DiffLineViewModel>();
             TargetDiffLines = new ObservableCollection<DiffLineViewModel>();
+            ObjectTypeFilters = new ObservableCollection<ObjectTypeFilterViewModel>(CreateObjectTypeFilters());
             PickSourceCommand = new RelayCommand(() => SetConnection(isSource: true));
             PickTargetCommand = new RelayCommand(() => SetConnection(isSource: false));
             ClearSourceCommand = new RelayCommand(() => SourceConnection = null, () => SourceConnection != null);
@@ -60,9 +60,12 @@ public SchemaCompareViewModel()
                 () => !IsBusy && (SourceConnection != null || TargetConnection != null));
             CompareCommand = new AsyncRelayCommand(CompareAsync, () => HasConnections && !IsBusy);
             CancelCompareCommand = new RelayCommand(CancelCompare, () => IsBusy);
+            GenerateDeploymentScriptCommand = new AsyncRelayCommand(GenerateDeploymentScriptAsync, () => _comparisonResult != null && Differences.Any(d => d.IsSelected));
             CopyDeploymentScriptCommand = new RelayCommand(CopyDeploymentScript, () => !string.IsNullOrEmpty(DeploymentScript));
             CopySourceDefinitionCommand = new RelayCommand(CopySourceDefinition, () => !string.IsNullOrEmpty(SelectedDifference?.SourceDefinition));
             CopyTargetDefinitionCommand = new RelayCommand(CopyTargetDefinition, () => !string.IsNullOrEmpty(SelectedDifference?.TargetDefinition));
+            IncludeAllObjectTypesCommand = new RelayCommand(() => SetAllObjectTypeFilters(true));
+            ExcludeAllObjectTypesCommand = new RelayCommand(() => SetAllObjectTypeFilters(false));
         }
 
         public ObservableCollection<SchemaDifferenceViewModel> Differences { get; }
@@ -71,6 +74,8 @@ public SchemaCompareViewModel()
 
         public ObservableCollection<DiffLineViewModel> TargetDiffLines { get; }
 
+        public ObservableCollection<ObjectTypeFilterViewModel> ObjectTypeFilters { get; }
+
         public ICommand PickSourceCommand { get; }
 
         public ICommand PickTargetCommand { get; }
@@ -85,12 +90,18 @@ public SchemaCompareViewModel()
 
         public ICommand CancelCompareCommand { get; }
 
+        public ICommand GenerateDeploymentScriptCommand { get; }
+
         public ICommand CopyDeploymentScriptCommand { get; }
 
         public ICommand CopySourceDefinitionCommand { get; }
 
         public ICommand CopyTargetDefinitionCommand { get; }
 
+        public ICommand IncludeAllObjectTypesCommand { get; }
+
+        public ICommand ExcludeAllObjectTypesCommand { get; }
+
         public bool HasConnections => SourceConnection != null && TargetConnection != null;
 
         public ScriptFactoryAccess.ConnectionInfo SourceConnection
@@ -225,6 +236,8 @@ private async Task CompareAsync()
                 SelectedDifference = null;
                 SourceDiffLines.Clear();
                 TargetDiffLines.Clear();
+                _comparisonResult = null;
+                _targetDatabaseName = string.Empty;
 
                 var sourceConnectionString = SourceConnection.FullConnectionString;
                 var targetConnectionString = TargetConnection.FullConnectionString;
@@ -236,6 +249,9 @@ private async Task CompareAsync()
                     var sourceEndpoint = new SchemaCompareDatabaseEndpoint(sourceConnectionString);
                     var targetEndpoint = new SchemaCompareDatabaseEndpoint(targetConnectionString);
                     var comparison = new SchemaComparison(sourceEndpoint, targetEndpoint);
+
+                    // ApplyObjectTypeFilters(comparison);
+
                     var result = comparison.Compare();
                     cancellationToken.ThrowIfCancellationRequested();
                     var scriptResult = result.GenerateScript(targetDatabase);
@@ -250,7 +266,10 @@ private async Task CompareAsync()
                 }
 
                 DeploymentScript = payload.Script;
+                _comparisonResult = payload.Result;
+                _targetDatabaseName = targetDatabase;
                 Status = Differences.Count == 0 ? "No differences were found." : $"Found {Differences.Count} difference(s).";
+                CommandManager.InvalidateRequerySuggested();
             }
             catch (OperationCanceledException)
             {
@@ -280,6 +299,52 @@ private void CancelCompare()
             _cancellationTokenSource?.Cancel();
         }
 
+        private async Task GenerateDeploymentScriptAsync()
+        {
+            if (_comparisonResult == null)
+            {
+                Status = "Run a comparison before generating a deployment script.";
+                return;
+            }
+
+            try
+            {
+                IsBusy = true;
+                var selectedCount = Differences.Count(d => d.IsSelected);
+                if (selectedCount == 0)
+                {
+                    DeploymentScript = string.Empty;
+                    Status = "No objects selected for script generation.";
+                    return;
+                }
+
+                string script = string.Empty;
+
+                await Task.Run(() =>
+                {
+                    foreach (var difference in Differences)
+                    {
+                        difference.ApplySelection();
+                    }
+
+                    script = _comparisonResult.GenerateScript(_targetDatabaseName)?.Script ?? string.Empty;
+                });
+
+                DeploymentScript = script;
+                Status = $"Deployment script generated for {selectedCount} selected object(s).";
+            }
+            catch (Exception ex)
+            {
+                Status = ex.Message;
+                MessageBox.Show(ex.Message, "Schema Compare", MessageBoxButton.OK, MessageBoxImage.Error);
+            }
+            finally
+            {
+                IsBusy = false;
+                CommandManager.InvalidateRequerySuggested();
+            }
+        }
+
         private void CopyDeploymentScript()
         {
             CopyTextToClipboard(DeploymentScript);
@@ -332,16 +397,59 @@ private void UpdateDiffPreview(SchemaDifferenceViewModel difference)
             }
         }
 
+        private void ApplyObjectTypeFilters(SchemaComparison comparison)
+        {
+            if (comparison?.Options?.ExcludeObjectTypes == null)
+            {
+                return;
+            }
+
+            Microsoft.SqlServer.Dac.ObjectType[] list = new Microsoft.SqlServer.Dac.ObjectType[ObjectTypeFilters.Count(f => !f.IsIncluded)];
+            foreach (var filter in ObjectTypeFilters.Where(f => !f.IsIncluded))
+            {
+                list.Append(filter.ObjectType).ToArray();
+            }
+
+            comparison.Options.ExcludeObjectTypes = list.ToArray();
+
+        }
+
+        private IEnumerable<ObjectTypeFilterViewModel> CreateObjectTypeFilters()
+        {
+            foreach (Microsoft.SqlServer.Dac.ObjectType objectType in Enum.GetValues(typeof(Microsoft.SqlServer.Dac.ObjectType)))
+            {
+                yield return new ObjectTypeFilterViewModel(objectType);
+            }
+        }
+
+        private void SetAllObjectTypeFilters(bool include)
+        {
+            foreach (var filter in ObjectTypeFilters)
+            {
+                filter.IsIncluded = include;
+            }
+
+            CommandManager.InvalidateRequerySuggested();
+        }
+
         private void OnPropertyChanged([CallerMemberName] string propertyName = null)
         {
             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
         }
     }
 
-    internal class SchemaDifferenceViewModel
+    internal class SchemaDifferenceViewModel : INotifyPropertyChanged
     {
+        private readonly SchemaDifference _difference;
+        private readonly SchemaComparisonResult _result;
+        private bool _isSelected;
+
         public SchemaDifferenceViewModel(SchemaDifference difference, SchemaComparisonResult result)
         {
+            _difference = difference ?? throw new ArgumentNullException(nameof(difference));
+            _result = result ?? throw new ArgumentNullException(nameof(result));
+            _isSelected = difference.Included;
+
             Name = difference.Name?.ToString() ?? string.Empty;
             DifferenceType = difference.DifferenceType.ToString();
             Action = difference.UpdateAction.ToString();
@@ -350,17 +458,36 @@ public SchemaDifferenceViewModel(SchemaDifference difference, SchemaComparisonRe
             TargetObject = difference.TargetObject?.Name.ToString() ?? string.Empty;
 
             var sbSource = new StringBuilder();
-            GetAllSourceChidren(difference, result, sbSource);
+            GetAllSourceChidren(difference, sbSource);
             SourceDefinition = sbSource.ToString();
 
             var sbTarget = new StringBuilder();
-            GetAllTargetChidren(difference, result, sbTarget);
+            GetAllTargetChidren(difference, sbTarget);
             TargetDefinition = sbTarget.ToString();
         }
 
-        public void GetAllSourceChidren(SchemaDifference difference, SchemaComparisonResult result, StringBuilder sb) 
+        public bool IsSelected
+        {
+            get => _isSelected;
+            set
+            {
+                if (_isSelected != value)
+                {
+                    _isSelected = value;
+                    OnPropertyChanged();
+                    CommandManager.InvalidateRequerySuggested();
+                }
+            }
+        }
+
+        public void ApplySelection()
         {
-            string stringResult = result.GetDiffEntrySourceScript(difference);
+            SetIncludedState(_difference, _isSelected);
+        }
+
+        private void GetAllSourceChidren(SchemaDifference difference, StringBuilder sb)
+        {
+            string stringResult = _result.GetDiffEntrySourceScript(difference);
             if (!string.IsNullOrWhiteSpace(stringResult))
             {
                 sb.AppendLine(stringResult);
@@ -371,14 +498,14 @@ public void GetAllSourceChidren(SchemaDifference difference, SchemaComparisonRes
             {
                 if (diff.Included)
                 {
-                    GetAllSourceChidren(diff, result, sb);
+                    GetAllSourceChidren(diff, sb);
                 }
             }
         }
 
-        public void GetAllTargetChidren(SchemaDifference difference, SchemaComparisonResult result, StringBuilder sb)
+        private void GetAllTargetChidren(SchemaDifference difference, StringBuilder sb)
         {
-            string stringResult = result.GetDiffEntryTargetScript(difference);
+            string stringResult = _result.GetDiffEntryTargetScript(difference);
             if (!string.IsNullOrWhiteSpace(stringResult))
             {
                 sb.AppendLine(stringResult);
@@ -389,11 +516,21 @@ public void GetAllTargetChidren(SchemaDifference difference, SchemaComparisonRes
             {
                 if (diff.Included)
                 {
-                    GetAllTargetChidren(diff, result, sb);
+                    GetAllTargetChidren(diff, sb);
                 }
             }
         }
 
+        private void SetIncludedState(SchemaDifference difference, bool isIncluded)
+        {
+            // difference.Included = isIncluded;
+
+            foreach (var child in difference.Children)
+            {
+                SetIncludedState(child, isIncluded);
+            }
+        }
+
         public string Name { get; }
 
         public string DifferenceType { get; }
@@ -407,6 +544,13 @@ public void GetAllTargetChidren(SchemaDifference difference, SchemaComparisonRes
         public string SourceDefinition { get; }
 
         public string TargetDefinition { get; }
+
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        private void OnPropertyChanged([CallerMemberName] string propertyName = null)
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
     }
 
     internal class DiffLineViewModel
@@ -446,6 +590,42 @@ private static string GetIndicator(ChangeType changeType)
         }
     }
 
+    internal class ObjectTypeFilterViewModel : INotifyPropertyChanged
+    {
+        private bool _isIncluded = true;
+
+        public ObjectTypeFilterViewModel(Microsoft.SqlServer.Dac.ObjectType objectType)
+        {
+            ObjectType = objectType;
+            DisplayName = objectType.ToString();
+        }
+
+        public Microsoft.SqlServer.Dac.ObjectType ObjectType { get; }
+
+        public string DisplayName { get; }
+
+        public bool IsIncluded
+        {
+            get => _isIncluded;
+            set
+            {
+                if (_isIncluded != value)
+                {
+                    _isIncluded = value;
+                    OnPropertyChanged();
+                    CommandManager.InvalidateRequerySuggested();
+                }
+            }
+        }
+
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        private void OnPropertyChanged([CallerMemberName] string propertyName = null)
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
+    }
+
     internal class AsyncRelayCommand : ICommand
     {
         private readonly Func<Task> _executeAsync;