diff --git a/.github/ISSUE_TEMPLATE/frontend-requirement-specification.md b/.github/ISSUE_TEMPLATE/frontend-requirement-specification.md
index 510f2c6..2ba040c 100644
--- a/.github/ISSUE_TEMPLATE/frontend-requirement-specification.md
+++ b/.github/ISSUE_TEMPLATE/frontend-requirement-specification.md
@@ -1,7 +1,7 @@
 ---
 name: Frontend Requirement Specification
 about: For specifying the frontend requirements of the project.
-title: Frontend – [Requirement Description]
+title: Frontend – [Requirement Description] – [Gui Element]
 labels: requirement
 assignees: ''
 
diff --git a/.github/workflows/build-test-ci.yml b/.github/workflows/build-test-ci.yml
index 4e6968f..797c608 100644
--- a/.github/workflows/build-test-ci.yml
+++ b/.github/workflows/build-test-ci.yml
@@ -9,12 +9,11 @@ jobs:
     strategy:
       matrix:
         targetplatform: [x64]
-        #targetplatform: [x86, x64]
 
     runs-on: windows-latest
 
     env:
-      Project_File: FAFB-PowerShell-Tool\FAFB-PowerShell-Tool.csproj
+      Project_File: ActiveDirectoryQuerier\ActiveDirectoryQuerier.csproj
 
     steps:
     - name: Checkout
@@ -31,7 +30,8 @@ jobs:
         Import-Module ActiveDirectory
 
     - name: Dotnet Restore & Build
-      run: dotnet build $env:Project_File -c Debug -f net6.0-windows -r win-${{ matrix.targetplatform }}
+      run: dotnet build $env:Project_File -c Debug -f net8.0-windows -r win-${{ matrix.targetplatform }}
 
-    - name: Dotnet Test
-      run: dotnet test
+    - name: Dotnet Test with Coverage
+      run: |
+        dotnet test $env:Project_File --no-build
diff --git a/.github/workflows/release-ci.yml b/.github/workflows/release-ci.yml
index cb29c6c..c394044 100644
--- a/.github/workflows/release-ci.yml
+++ b/.github/workflows/release-ci.yml
@@ -16,7 +16,7 @@ jobs:
     runs-on: windows-latest
 
     env:
-      Project_File: FAFB-PowerShell-Tool\FAFB-PowerShell-Tool.csproj
+      Project_File: ActiveDirectoryQuerier\ActiveDirectoryQuerier.csproj
 
     steps:
     - name: Checkout
@@ -30,15 +30,15 @@ jobs:
     - name: Dotnet Build & Publish
       run: |
         dotnet build $env:Project_File -c Release -f net6.0-windows -r win-${{ matrix.targetplatform }}
-        dotnet publish $env:Project_File -c Release -f net6.0-windows -r win-${{ matrix.targetplatform }} -o ./publish/FAFB_PowerShell_Tool_${{ matrix.targetplatform }}
+        dotnet publish $env:Project_File -c Release -f net6.0-windows -r win-${{ matrix.targetplatform }} -o ./publish/ActiveDirectoryQuerier_${{ matrix.targetplatform }}
 
     - name: Zip Release Files
-      run: Compress-Archive -Path .\publish\FAFB_PowerShell_Tool_${{ matrix.targetplatform }} -DestinationPath .\FAFB_PowerShell_Tool_${{ matrix.targetplatform }}.zip
+      run: Compress-Archive -Path .\publish\ActiveDirectoryQuerier_${{ matrix.targetplatform }} -DestinationPath .\ActiveDirectoryQuerier_${{ matrix.targetplatform }}.zip
 
     - name: Create Release
       id: create_release
       uses: softprops/action-gh-release@v1
       with:
-        files: FAFB_PowerShell_Tool_${{ matrix.targetplatform }}.zip
+        files: ActiveDirectoryQuerier_${{ matrix.targetplatform }}.zip
       env:
         GITHUB_TOKEN: ${{ secrets.RELEASE_TOKEN }}
diff --git a/.gitignore b/.gitignore
index e0bed98..248bc4c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -476,14 +476,14 @@ $RECYCLE.BIN/
 # Windows shortcuts
 *.lnk
 
-.vscode/launch.json
-
-.vscode/tasks.json
+# Rider files
+.idea
 
-.idea/.idea.FAFB-PowerShell-Tool/.idea/indexLayout.xml
 
-.idea/.idea.FAFB-PowerShell-Tool/.idea/workspace.xml
-
-FAFB-PowerShell-Tool/FAFB-PowerShell-Tool-Output.txt
+# VSCode files
+.vscode/launch.json
+.vscode/tasks.json
 
-.idea/.idea.FAFB-PowerShell-Tool/.idea/
+# Text and CSV files
+*.txt
+*.csv
diff --git a/FAFB-PowerShell-Tool.Tests/ActiveDirectoryCommandsTests.cs b/ActiveDirectoryQuerier.Tests/ActiveDirectoryCommandsTests.cs
similarity index 88%
rename from FAFB-PowerShell-Tool.Tests/ActiveDirectoryCommandsTests.cs
rename to ActiveDirectoryQuerier.Tests/ActiveDirectoryCommandsTests.cs
index b622785..267c130 100644
--- a/FAFB-PowerShell-Tool.Tests/ActiveDirectoryCommandsTests.cs
+++ b/ActiveDirectoryQuerier.Tests/ActiveDirectoryCommandsTests.cs
@@ -1,9 +1,8 @@
 using System.Collections.ObjectModel;
-using System.Management.Automation;
 using System.Management.Automation.Runspaces;
-using FAFB_PowerShell_Tool.PowerShell;
+using ActiveDirectoryQuerier.PowerShell;
 
-namespace FAFB_PowerShell_Tool.Tests;
+namespace ActiveDirectoryQuerier.Tests;
 
 public class ActiveDirectoryCommandsTests
 {
diff --git a/FAFB-PowerShell-Tool.Tests/FAFB-PowerShell-Tool.Tests.csproj b/ActiveDirectoryQuerier.Tests/ActiveDirectoryQuerier.Tests.csproj
similarity index 62%
rename from FAFB-PowerShell-Tool.Tests/FAFB-PowerShell-Tool.Tests.csproj
rename to ActiveDirectoryQuerier.Tests/ActiveDirectoryQuerier.Tests.csproj
index 557a86e..ee0dbed 100644
--- a/FAFB-PowerShell-Tool.Tests/FAFB-PowerShell-Tool.Tests.csproj
+++ b/ActiveDirectoryQuerier.Tests/ActiveDirectoryQuerier.Tests.csproj
@@ -1,29 +1,25 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net6.0-windows</TargetFramework>
-        <RootNamespace>FAFB_PowerShell_Tool.Tests</RootNamespace>
-        <ImplicitUsings>enable</ImplicitUsings>
-        <Nullable>enable</Nullable>
-        <EnableNETAnalyzers>true</EnableNETAnalyzers>
-
         <IsPackable>false</IsPackable>
+		<AssemblyName>ActiveDirectoryQuerier.Tests</AssemblyName>
+        <RootNamespace>ActiveDirectoryQuerier.Tests</RootNamespace>
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
-        <PackageReference Include="xunit" Version="2.6.6" />
-        <PackageReference Include="xunit.runner.visualstudio" Version="2.5.6">
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.9.0" />
+        <PackageReference Include="xunit" Version="2.7.0" />
+        <PackageReference Include="xunit.runner.visualstudio" Version="2.5.7">
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
             <PrivateAssets>all</PrivateAssets>
         </PackageReference>
-        <PackageReference Include="coverlet.collector" Version="6.0.0">
+        <PackageReference Include="coverlet.collector" Version="6.0.1">
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
             <PrivateAssets>all</PrivateAssets>
         </PackageReference>
     </ItemGroup>
 
     <ItemGroup>
-      <ProjectReference Include="..\FAFB-PowerShell-Tool\FAFB-PowerShell-Tool.csproj" />
+      <ProjectReference Include="..\ActiveDirectoryQuerier\ActiveDirectoryQuerier.csproj" />
     </ItemGroup>
 </Project>
diff --git a/FAFB-PowerShell-Tool.Tests/CommandParametersTests.cs b/ActiveDirectoryQuerier.Tests/CommandParametersTests.cs
similarity index 93%
rename from FAFB-PowerShell-Tool.Tests/CommandParametersTests.cs
rename to ActiveDirectoryQuerier.Tests/CommandParametersTests.cs
index 00b6c73..aa749a2 100644
--- a/FAFB-PowerShell-Tool.Tests/CommandParametersTests.cs
+++ b/ActiveDirectoryQuerier.Tests/CommandParametersTests.cs
@@ -1,7 +1,7 @@
 using System.Management.Automation.Runspaces;
-using FAFB_PowerShell_Tool.PowerShell;
+using ActiveDirectoryQuerier.PowerShell;
 
-namespace FAFB_PowerShell_Tool.Tests;
+namespace ActiveDirectoryQuerier.Tests;
 
 public class CommandParametersTests
 {
@@ -28,7 +28,7 @@ public async Task LoadCommandParametersAsync_PopulatesPossibleParameters_IsNotEm
         // Assert
         Assert.NotEmpty(commandParameters.PossibleParameters);
     }
-    
+
     [Fact]
     public async Task LoadCommandParametersAsync_CheckPossibleParameter_ContentIsCorrect()
     {
diff --git a/FAFB-PowerShell-Tool.Tests/GlobalUsings.cs b/ActiveDirectoryQuerier.Tests/GlobalUsings.cs
similarity index 100%
rename from FAFB-PowerShell-Tool.Tests/GlobalUsings.cs
rename to ActiveDirectoryQuerier.Tests/GlobalUsings.cs
diff --git a/FAFB-PowerShell-Tool.Tests/PowerShellExecutorTests.cs b/ActiveDirectoryQuerier.Tests/PowerShellExecutorTests.cs
similarity index 94%
rename from FAFB-PowerShell-Tool.Tests/PowerShellExecutorTests.cs
rename to ActiveDirectoryQuerier.Tests/PowerShellExecutorTests.cs
index b62f992..24c8828 100644
--- a/FAFB-PowerShell-Tool.Tests/PowerShellExecutorTests.cs
+++ b/ActiveDirectoryQuerier.Tests/PowerShellExecutorTests.cs
@@ -1,7 +1,7 @@
 using System.Management.Automation.Runspaces;
-using FAFB_PowerShell_Tool.PowerShell;
+using ActiveDirectoryQuerier.PowerShell;
 
-namespace FAFB_PowerShell_Tool.Tests;
+namespace ActiveDirectoryQuerier.Tests;
 
 public class PowerShellExecutorTests
 {
@@ -23,7 +23,7 @@ public void Execute_WhenGivenValidCommand_ReturnsExpectedOutput(string cmd, stri
         Assert.Empty(result.StdErr);
         Assert.NotEmpty(result.StdOut);
     }
-    
+
     [Fact]
     public void Execute_CheckIfOutputChanged_ReturnsDifferentOutput()
     {
@@ -45,7 +45,7 @@ public void Execute_CheckIfOutputChanged_ReturnsDifferentOutput()
     [Theory]
     [InlineData("Get-Command", "Module", "ActiveDirectory")]
     [InlineData("Get-Process", "Name", "explorer")]
-    public async void ExecuteAsync_WhenGivenValidCommand_ReturnsExpectedOutput(string cmd,
+    public async Task ExecuteAsync_WhenGivenValidCommand_ReturnsExpectedOutput(string cmd,
                                                                                string paramName,
                                                                                string paramValue)
     {
@@ -85,7 +85,7 @@ public void Execute_WhenGivenInvalidCommand_ReturnsExpectedOutput(string cmd, st
     [Theory]
     [InlineData("Get-ADUser", "InvalidParameter", "*")]
     [InlineData("InvalidCommand", "Filter", "*")]
-    public async void ExecuteAsync_WhenGivenInvalidCommand_ReturnsExpectedOutput(string cmd,
+    public async Task ExecuteAsync_WhenGivenInvalidCommand_ReturnsExpectedOutput(string cmd,
                                                                                  string paramName,
                                                                                  string paramValue)
     {
diff --git a/FAFB-PowerShell-Tool.Tests/RelayCommandTests.cs b/ActiveDirectoryQuerier.Tests/RelayCommandTests.cs
similarity index 93%
rename from FAFB-PowerShell-Tool.Tests/RelayCommandTests.cs
rename to ActiveDirectoryQuerier.Tests/RelayCommandTests.cs
index 2d8d060..b44ba75 100644
--- a/FAFB-PowerShell-Tool.Tests/RelayCommandTests.cs
+++ b/ActiveDirectoryQuerier.Tests/RelayCommandTests.cs
@@ -1,4 +1,4 @@
-namespace FAFB_PowerShell_Tool.Tests;
+namespace ActiveDirectoryQuerier.Tests;
 
 public class RelayCommandTests
 {
@@ -76,6 +76,7 @@ public void CanExecuteChanged_WithNullParameter_DoesNotThrow2()
         RelayCommand command = new(
             _ =>
             {});
+        // ReSharper disable once EventUnsubscriptionViaAnonymousDelegate
         command.CanExecuteChanged -= (_, _) =>
         {};
     }
diff --git a/FAFB-PowerShell-Tool.Tests/ReturnValuesTest.cs b/ActiveDirectoryQuerier.Tests/ReturnValuesTest.cs
similarity index 90%
rename from FAFB-PowerShell-Tool.Tests/ReturnValuesTest.cs
rename to ActiveDirectoryQuerier.Tests/ReturnValuesTest.cs
index fac5a3d..7e75175 100644
--- a/FAFB-PowerShell-Tool.Tests/ReturnValuesTest.cs
+++ b/ActiveDirectoryQuerier.Tests/ReturnValuesTest.cs
@@ -1,6 +1,6 @@
-using FAFB_PowerShell_Tool.PowerShell;
+using ActiveDirectoryQuerier.PowerShell;
 
-namespace FAFB_PowerShell_Tool.Tests;
+namespace ActiveDirectoryQuerier.Tests;
 
 public class ReturnValuesTest
 {
diff --git a/FAFB-PowerShell-Tool.sln b/ActiveDirectoryQuerier.sln
similarity index 91%
rename from FAFB-PowerShell-Tool.sln
rename to ActiveDirectoryQuerier.sln
index 1cbddd3..953b81b 100644
--- a/FAFB-PowerShell-Tool.sln
+++ b/ActiveDirectoryQuerier.sln
@@ -2,9 +2,9 @@ Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 17
 VisualStudioVersion = 17.8.34309.116
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "FAFB-PowerShell-Tool", "FAFB-PowerShell-Tool\FAFB-PowerShell-Tool.csproj", "{C6E51308-E9E0-4738-9D5A-49841912633B}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ActiveDirectoryQuerier", "ActiveDirectoryQuerier\ActiveDirectoryQuerier.csproj", "{C6E51308-E9E0-4738-9D5A-49841912633B}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FAFB-PowerShell-Tool.Tests", "FAFB-PowerShell-Tool.Tests\FAFB-PowerShell-Tool.Tests.csproj", "{C1FD9137-6780-44AE-9920-A566FC555F68}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ActiveDirectoryQuerier.Tests", "ActiveDirectoryQuerier.Tests\ActiveDirectoryQuerier.Tests.csproj", "{C1FD9137-6780-44AE-9920-A566FC555F68}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
diff --git a/ActiveDirectoryQuerier/ActiveDirectoryQuerier.csproj b/ActiveDirectoryQuerier/ActiveDirectoryQuerier.csproj
new file mode 100644
index 0000000..29697df
--- /dev/null
+++ b/ActiveDirectoryQuerier/ActiveDirectoryQuerier.csproj
@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<OutputType>WinExe</OutputType>
+		<PlatformTarget>x64</PlatformTarget>
+		<UseWPF>true</UseWPF>
+		<AssemblyName>ActiveDirectoryQuerier</AssemblyName>
+		<RootNamespace>ActiveDirectoryQuerier</RootNamespace>
+
+		<!-- Project Info. -->
+		<Title>Active Directory Querier</Title>
+		<Version>0.4.1</Version>
+		<Authors>Hunter T., Pieter Landry Sobtafo, Joseph</Authors>
+		<RepositoryUrl>https://github.com/StrangeRanger/FAFB-PowerShell-Tool</RepositoryUrl>
+
+		<!-- Project Compile Time Settings. -->
+		<PublishSingleFile>false</PublishSingleFile>
+		<SelfContained>true</SelfContained>
+		<DebugType>embedded</DebugType>
+		<IncludeNativeLibrariesForSelfExtract>true</IncludeNativeLibrariesForSelfExtract>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<PackageReference Include="Microsoft.Management.Infrastructure" Version="3.0.0" />
+		<PackageReference Include="Microsoft.PowerShell.SDK" Version="7.2.18" />
+	</ItemGroup>
+
+</Project>
diff --git a/FAFB-PowerShell-Tool/App.xaml b/ActiveDirectoryQuerier/App.xaml
similarity index 70%
rename from FAFB-PowerShell-Tool/App.xaml
rename to ActiveDirectoryQuerier/App.xaml
index 251099b..4a1f861 100644
--- a/FAFB-PowerShell-Tool/App.xaml
+++ b/ActiveDirectoryQuerier/App.xaml
@@ -1,7 +1,6 @@
-<Application x:Class="FAFB_PowerShell_Tool.App"
+<Application x:Class="ActiveDirectoryQuerier.App"
              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             xmlns:local="clr-namespace:FAFB_PowerShell_Tool"
              StartupUri="MainWindow.xaml">
     <Application.Resources>
          
diff --git a/FAFB-PowerShell-Tool/App.xaml.cs b/ActiveDirectoryQuerier/App.xaml.cs
similarity index 79%
rename from FAFB-PowerShell-Tool/App.xaml.cs
rename to ActiveDirectoryQuerier/App.xaml.cs
index b06bd4e..8f83fe4 100644
--- a/FAFB-PowerShell-Tool/App.xaml.cs
+++ b/ActiveDirectoryQuerier/App.xaml.cs
@@ -1,6 +1,6 @@
 using System.Windows;
 
-namespace FAFB_PowerShell_Tool;
+namespace ActiveDirectoryQuerier;
 
 /// <summary>
 /// Interaction logic for App.xaml
diff --git a/FAFB-PowerShell-Tool/AssemblyInfo.cs b/ActiveDirectoryQuerier/AssemblyInfo.cs
similarity index 100%
rename from FAFB-PowerShell-Tool/AssemblyInfo.cs
rename to ActiveDirectoryQuerier/AssemblyInfo.cs
diff --git a/FAFB-PowerShell-Tool/ComboBoxParameterViewModel.cs b/ActiveDirectoryQuerier/ComboBoxParameterViewModel.cs
similarity index 75%
rename from FAFB-PowerShell-Tool/ComboBoxParameterViewModel.cs
rename to ActiveDirectoryQuerier/ComboBoxParameterViewModel.cs
index e174408..b9c800e 100644
--- a/FAFB-PowerShell-Tool/ComboBoxParameterViewModel.cs
+++ b/ActiveDirectoryQuerier/ComboBoxParameterViewModel.cs
@@ -1,7 +1,7 @@
 using System.Collections.ObjectModel;
 using System.ComponentModel;
 
-namespace FAFB_PowerShell_Tool;
+namespace ActiveDirectoryQuerier;
 
 /// <summary>
 /// ViewModel for a ComboBox that displays possible parameters for a PowerShell command.
@@ -12,13 +12,6 @@ public sealed class ComboBoxParameterViewModel : INotifyPropertyChanged
     public event PropertyChangedEventHandler? PropertyChanged;
     private ObservableCollection<string> _possibleParameterList = new();
     private string _selectedParameter = string.Empty;
-    private string _selectedParameterValue = string.Empty;
-
-    /// <summary>
-    /// Empty constructor to initialize a new ComboBoxParameterViewModel.
-    /// </summary>
-    public ComboBoxParameterViewModel()
-    { }
 
     /// <summary>
     /// Initializes a new instance of the ComboBoxParameterViewModel class.
@@ -30,7 +23,7 @@ public ComboBoxParameterViewModel(ObservableCollection<string> possibleParameter
     }
 
     /// <summary>
-    /// Sets a unique selected value for each combo box
+    /// Sets a unique selected value for each combo box.
     /// </summary>
     public string SelectedParameter
     {
@@ -44,21 +37,6 @@ public string SelectedParameter
         }
     }
 
-    /// <summary>
-    /// Gets or sets the selected parameter value for the unique ComboBox.
-    /// </summary>
-    public string SelectedParameterValue
-    {
-        get => _selectedParameterValue;
-        set {
-            if (_selectedParameterValue != value)
-            {
-                _selectedParameterValue = value;
-                OnPropertyChanged(nameof(SelectedParameterValue));
-            }
-        }
-    }
-
     /// <summary>
     /// Gets or sets the list of possible parameters that can be selected for a command.
     /// </summary>
diff --git a/FAFB-PowerShell-Tool/MainWindow.xaml b/ActiveDirectoryQuerier/MainWindow.xaml
similarity index 81%
rename from FAFB-PowerShell-Tool/MainWindow.xaml
rename to ActiveDirectoryQuerier/MainWindow.xaml
index 41145df..056efe5 100644
--- a/FAFB-PowerShell-Tool/MainWindow.xaml
+++ b/ActiveDirectoryQuerier/MainWindow.xaml
@@ -1,13 +1,13 @@
-<Window x:Class="FAFB_PowerShell_Tool.MainWindow"
+<Window x:Class="ActiveDirectoryQuerier.MainWindow"
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         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:local="clr-namespace:FAFB_PowerShell_Tool"
+        xmlns:activeDirectoryQuerier="clr-namespace:ActiveDirectoryQuerier"
         mc:Ignorable="d"
         Title="Active Directory Querier" Height="720" Width="1280">
     <Window.DataContext>
-        <local:MainWindowViewModel />
+        <activeDirectoryQuerier:MainWindowViewModel />
     </Window.DataContext>
 
     <Grid>
@@ -36,28 +36,30 @@
             </Grid.ColumnDefinitions>
 
             <!-- Left Side Query Bar (Content in first column) -->
-            <Grid x:Name="LeftSideQueryGrid" Grid.Column="0">
-                <Grid.BindingGroup>
-                    <BindingGroup/>
-                </Grid.BindingGroup>
+            <ScrollViewer VerticalScrollBarVisibility="Auto" HorizontalScrollBarVisibility="Auto">
+                <Grid x:Name="LeftSideQueryGrid" Grid.Column="0">
+                    <Grid.BindingGroup>
+                        <BindingGroup/>
+                    </Grid.BindingGroup>
 
-                <Grid.Background>
-                    <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
-                        <GradientStop Color="#FF616161" Offset="0"/>
-                        <GradientStop Color="#FF5F5F5F" Offset="0.363"/>
-                        <GradientStop Color="#FF898989" Offset="0.737"/>
-                    </LinearGradientBrush>
-                </Grid.Background>
+                    <Grid.Background>
+                        <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
+                            <GradientStop Color="#FF616161" Offset="0"/>
+                            <GradientStop Color="#FF5F5F5F" Offset="0.363"/>
+                            <GradientStop Color="#FF898989" Offset="0.737"/>
+                        </LinearGradientBrush>
+                    </Grid.Background>
 
-                <!-- Stacked Queries are placed here. -->
-                <ItemsControl ItemsSource="{Binding ButtonStackPanel}">
-                    <ItemsControl.ItemTemplate>
-                        <DataTemplate>
-                            <Button Content="{Binding Content}" Command="{Binding Command}" />
-                        </DataTemplate>
-                    </ItemsControl.ItemTemplate>
-                </ItemsControl>
-            </Grid>
+                    <!-- Stacked Queries are placed here. -->
+                    <ItemsControl ItemsSource="{Binding QueryButtonStackPanel}">
+                        <ItemsControl.ItemTemplate>
+                            <DataTemplate>
+                                <Button Content="{Binding Content}" Command="{Binding Command}" />
+                            </DataTemplate>
+                        </ItemsControl.ItemTemplate>
+                    </ItemsControl>
+                </Grid>
+            </ScrollViewer>
 
             <!-- Grid Splitter for resizing. -->
             <GridSplitter Grid.Column="1" Width="5" HorizontalAlignment="Center" Background="Gray" />
@@ -102,9 +104,8 @@
                                     <ColumnDefinition Width="Auto"/>
                                 </Grid.ColumnDefinitions>
 
-                                <ComboBox x:Name="ComboBoxCommandList" 
-                                              ItemsSource="{Binding ActiveDirectoryCommandList}" 
-                                              SelectedItem="{Binding SelectedCommand}"
+                                <ComboBox ItemsSource="{Binding ActiveDirectoryCommandsList}" 
+                                              SelectedItem="{Binding SelectedComboBoxCommand}"
                                               DisplayMemberPath="CommandText" 
                                               HorizontalAlignment="Center" 
                                               VerticalAlignment="Center" 
@@ -113,8 +114,7 @@
                                               Grid.Column="0"/>
 
                                 <!-- ItemsControl for Dynamic ComboBoxes -->
-                                <ItemsControl x:Name="DynamicComboBoxes" 
-                                              ItemsSource="{Binding DynamicParameterCollection}"
+                                <ItemsControl ItemsSource="{Binding DynamicParametersCollection}"
                                               Grid.Column="1">
                                     <ItemsControl.ItemTemplate>
                                         <DataTemplate>
@@ -130,20 +130,10 @@
                                     </ItemsControl.ItemTemplate>
                                 </ItemsControl>
                                 <!-- TODO: Fill these-->
-                                <ItemsControl x:Name="DynamicComboBoxesValues" 
-                                              ItemsSource="{Binding DynamicParameterValuesCollection}"
+                                <ItemsControl ItemsSource="{Binding DynamicParameterValuesCollection}"
                                               Grid.Column="2">
                                     <ItemsControl.ItemTemplate>
                                         <DataTemplate>
-                                            <!--
-                                            <ComboBox Width="212"
-                                                      IsEditable="True"
-                                                      HorizontalAlignment="Left"
-                                                      VerticalAlignment="Center"
-                                                      Margin="5"
-                                                      SelectedItem="{Binding SelectedParameter}"
-                                                      />
-                                            -->
                                             <TextBox Width="212"
                                                      HorizontalAlignment="Left"
                                                      VerticalAlignment="Center"
@@ -154,7 +144,7 @@
                                     </ItemsControl.ItemTemplate>
                                 </ItemsControl>
                             </Grid>
-                            <!--
+                   
                             <Grid Grid.Row="1" Margin="12,16,12,16">
                                 <Grid.ColumnDefinitions>
                                     <ColumnDefinition Width="*" />
@@ -168,23 +158,22 @@
                                 
                                 
                                 <Button Content="Add New Command Slot"
-                                        Command="{Binding AddCommandComboBox}"
+                                        Command="{Binding AddCommandComboBoxRelay}"
                                         Grid.Column="0"/>
                                 <Button Content="Add New Parameter Slot"
-                                        Command="{Binding AddNewParameterComboBox}"
+                                        Command="{Binding AddParameterComboBoxRelay}"
                                         Grid.Column="1"/>
                                 <Button Content="Remove Parameter Slot"
-                                        Command="{Binding Remove_ParameterComboBox}"
+                                        Command="{Binding RemoveParameterComboBoxRelay}"
                                         Grid.Column="2"
-                                        Grid.Row="1"
                                         />
                                 
                                 <Button x:Name="SaveQueryButton"
                                             Content="Save Query"
-                                            Command="{Binding SavedQueries}"
+                                            Command="{Binding SaveCustomQueriesRelay}"
                                             Grid.Column="3" />
                                 <Button Content="Execute"
-                                            Command="{Binding ExecuteCommand}"
+                                            Command="{Binding ExecuteCommandRelay}"
                                             Grid.Column="4" />
                                 <Button Content="Export Console Output"
                                         Command="{Binding ExportConsoleOutput}"
@@ -193,7 +182,7 @@
                                         Command="{Binding ClearConsoleOutput}"
                                         Grid.Column="6" />
                             </Grid>
-                             -->
+                             
                             <!-- GridSplitter for resizing console area in the second row -->
                             <GridSplitter Height="5" HorizontalAlignment="Stretch" VerticalAlignment="Center" Background="White" Grid.Row="2" Grid.ColumnSpan="2"/>
 
@@ -203,30 +192,30 @@
                                 <TextBox Text="{Binding PowerShellOutput}" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Margin="10" IsReadOnly="True" TextWrapping="Wrap" VerticalScrollBarVisibility="Auto"/>
                             </Grid>
                             <!-- Menu options  -->
-                                <Menu x:Name="OptionsMenu" Width="Auto" Height="20" Margin="10,15,934,64">
+                                <Menu Grid.Row="0" x:Name="OptionsMenu" Width="Auto" Height="20" Margin="10,15,934,64">
                                 <MenuItem Header="Options">
                                     <MenuItem Header="Add New Command Slot"
-                                              Command="{Binding AddCommandComboBox}"
+                                              Command="{Binding AddCommandComboBoxRelay}"
                                               />
                                     <MenuItem Header="Add New Parameter Slot"
-                                              Command="{Binding AddNewParameterComboBox}"
+                                              Command="{Binding AddParameterComboBoxRelay}"
                                               />
                                     <MenuItem Header="Remove Parameter Slot"
-                                              Command="{Binding Remove_ParameterComboBox}"
+                                              Command="{Binding RemoveParameterComboBoxRelay}"
                                               />
                                     <MenuItem Header="Save Query"
-                                              Command="{Binding SavedQueries}"
+                                              Command="{Binding SaveCustomQueriesRelay}"
                                               />
                                     <MenuItem Header="Execute"
-                                              Command="{Binding ExecuteCommand}"
+                                              Command="{Binding ExecuteCommandRelay}"
                                               >
                                         <MenuItem Header="Output to console"
-                                                  Command="{Binding ExecuteCommand}"
+                                                  Command="{Binding ExecuteCommandRelay}"
                                                   />
                                         <MenuItem Header="Output to Csv"
-                                                  Command="{Binding OutputToCsv}"/>
+                                                  Command="{Binding OutputToCsvFileRelay}"/>
                                         <MenuItem Header="Output to Text"
-                                                  Command="{Binding _OutputToText}"/>
+                                                  Command="{Binding OutputToTextFileRelay}"/>
                                     </MenuItem>
                                     <MenuItem Header="Export Console Output"
                                               Command="{Binding ExportConsoleOutput}"
diff --git a/FAFB-PowerShell-Tool/MainWindow.xaml.cs b/ActiveDirectoryQuerier/MainWindow.xaml.cs
similarity index 75%
rename from FAFB-PowerShell-Tool/MainWindow.xaml.cs
rename to ActiveDirectoryQuerier/MainWindow.xaml.cs
index 187698d..ed4f897 100644
--- a/FAFB-PowerShell-Tool/MainWindow.xaml.cs
+++ b/ActiveDirectoryQuerier/MainWindow.xaml.cs
@@ -1,4 +1,4 @@
-namespace FAFB_PowerShell_Tool;
+namespace ActiveDirectoryQuerier;
 
 public partial class MainWindow
 {
diff --git a/ActiveDirectoryQuerier/MainWindowViewModel.cs b/ActiveDirectoryQuerier/MainWindowViewModel.cs
new file mode 100644
index 0000000..bfb9726
--- /dev/null
+++ b/ActiveDirectoryQuerier/MainWindowViewModel.cs
@@ -0,0 +1,759 @@
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.IO;
+using System.Management.Automation.Runspaces;
+using System.Text;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using ActiveDirectoryQuerier.PowerShell;
+using Microsoft.Win32;
+using static ActiveDirectoryQuerier.PowerShell.CustomQueries;
+
+namespace ActiveDirectoryQuerier;
+
+/// <summary>
+/// Primary view model for the MainWindow.
+/// </summary>
+public sealed class MainWindowViewModel : INotifyPropertyChanged
+{
+    // [ Fields ]-------------------------------------------------------------------- //
+    // [[ Event handler property ]] ------------------------------------------------- //
+
+    public event PropertyChangedEventHandler? PropertyChanged;
+
+    // [[ Backing fields for properties ]] ------------------------------------------ //
+
+    private string _powerShellOutput;
+    private string _queryName;
+    private string _queryDescription;
+    private Command? _selectedComboBoxCommand;
+    private ObservableCollection<Button>? _buttons;
+
+    // [[ Other fields ]] ----------------------------------------------------------- //
+
+    private readonly CustomQueries _customQuery;
+    private readonly CustomQueries.Query _currentQuery;
+    // Probably want to add the ability to toggle editing vs not editing but filled in.
+    private CustomQueries.Query? _isEditing;
+    private readonly PowerShellExecutor _powerShellExecutor;
+
+    // [ Properties ] --------------------------------------------------------------- //
+    // [[ Properties for backing fields ]] ------------------------------------------ //
+
+    /// <summary>
+    /// Gets or sets the output of the executed PowerShell command.
+    /// </summary>
+    public string PowerShellOutput
+    {
+        get => _powerShellOutput;
+        set {
+            _powerShellOutput = value;
+            OnPropertyChanged(nameof(PowerShellOutput));
+        }
+    }
+
+    /// <summary>
+    /// The name of the query.
+    /// </summary>
+    public string QueryName
+    {
+        get => _queryName;
+        set {
+            if (_queryName != value)
+            {
+                _queryName = value;
+                OnPropertyChanged(nameof(QueryName));
+            }
+        }
+    }
+
+    /// <summary>
+    /// The description of the query.
+    /// </summary>
+    public string QueryDescription
+    {
+        get => _queryDescription;
+        set {
+            if (_queryDescription != value)
+            {
+                _queryDescription = value;
+                OnPropertyChanged(nameof(QueryDescription));
+            }
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets the currently selected PowerShell command.
+    /// </summary>
+    public Command? SelectedComboBoxCommand
+    {
+        get => _selectedComboBoxCommand;
+        set {
+            _selectedComboBoxCommand = value;
+            OnPropertyChanged(nameof(SelectedComboBoxCommand));
+            LoadCommandParametersAsync(value);
+        }
+    }
+
+    /// <summary>
+    /// This property creates a collection of buttons to be added to the stack panel for custom queries
+    /// </summary>
+    public ObservableCollection<Button> QueryButtonStackPanel => _buttons ??= new ObservableCollection<Button>();
+
+    // [[ Other properties ]] ------------------------------------------------------- //
+
+    /// <summary>
+    /// Collection of Active Directory commands available for execution.
+    /// </summary>
+    public ObservableCollection<Command> ActiveDirectoryCommandsList { get; private set; }
+
+    /// <summary>
+    /// Collection of possible parameters for the currently selected command.
+    /// </summary>
+    public ObservableCollection<string>? PossibleCommandParametersList { get; private set; }
+
+    /// <summary>
+    /// Collection of ComboBoxParameterViewModels to dynamically handle multiple parameter selections.
+    /// </summary>
+    public ObservableCollection<ComboBoxParameterViewModel> DynamicParametersCollection { get; }
+
+    /// <summary>
+    /// Collection of ComboBoxParameterViewModels to dynamically handle multiple parameter value selections.
+    /// </summary>
+    public ObservableCollection<TextBoxViewModel> DynamicParameterValuesCollection { get; }
+
+    /// <summary>
+    /// This is a helper command for running SaveCustomQueries
+    /// </summary>
+    public ICommand SaveCustomQueriesRelay { get; }
+
+    /// <summary>
+    /// This is the command for the edit option on custom queries
+    /// TODO: Change property name to be a non-verb.
+    /// </summary>
+    private ICommand EditCustomQueryRelay { get; }
+
+    /// <summary>
+    /// TODO: Add a summary.
+    /// </summary>
+    private ICommand DeleteCustomQueryRelay { get; }
+
+    /// <summary>
+    /// Command to execute the selected PowerShell command.
+    /// TODO: Change property name???
+    /// </summary>
+    public ICommand ExecuteCommandRelay { get; }
+
+    /// <summary>
+    /// Command to execute the buttons inside Custom Command buttons
+    /// TODO: Change property name???
+    /// </summary>
+    private ICommand ExecuteCommandButtonRelay { get; }
+
+    /// <summary>
+    /// Command to add a new parameter ComboBox to the UI.
+    /// </summary>
+    public ICommand AddParameterComboBoxRelay { get; }
+
+    /// <summary>
+    /// Command to add a new command ComboBox to the UI.
+    /// </summary>
+    public ICommand AddCommandComboBoxRelay { get; }
+
+    /// <summary>
+    /// Command to add a new parameter ComboBox to the UI.
+    /// TODO: Rename this property to match Property naming conventions!!!
+    /// </summary>
+    public ICommand RemoveParameterComboBoxRelay { get; }
+
+    /// <summary>
+    /// Command to have the output send to a text file when executing
+    /// TODO: Get-only auto-property 'OutputToTextFileAsync' is never assigned!!!
+    /// </summary>
+    public ICommand OutputToTextFileRelay { get; }
+
+    /// <summary>
+    /// Command to output to a csv when executing
+    /// </summary>
+    public ICommand OutputToCsvFileRelay { get; }
+
+    // [ Constructors ] ------------------------------------------------------------ //
+
+    /// <summary>
+    /// Class constructor.
+    /// TODO: Fix warnings about possible null values.
+    /// </summary>
+    public MainWindowViewModel()
+    {
+        // TODO: Possibly make the fields nullable to enforce they are filled when saved and such.
+        _powerShellOutput = string.Empty;
+        // TODO: Possibly make the fields nullable to enforce they are filled when saved and such.
+        _queryName = string.Empty;
+        // TODO: Possibly make the fields nullable to enforce they are filled when saved and such.
+        _queryDescription = string.Empty;
+        _powerShellExecutor = new PowerShellExecutor();
+        _customQuery = new CustomQueries();
+        _currentQuery = new CustomQueries.Query();
+
+        ActiveDirectoryCommandsList = new ObservableCollection<Command>();
+        DynamicParametersCollection = new ObservableCollection<ComboBoxParameterViewModel>();
+        DynamicParameterValuesCollection = new ObservableCollection<TextBoxViewModel>();
+
+        ExecuteCommandRelay = new RelayCommand(ExecuteCommandAsync);
+        OutputToCsvFileRelay = new RelayCommand(OutputToCsvFileAsync);
+        OutputToTextFileRelay = new RelayCommand(OutputToTextFileAsync);
+        AddParameterComboBoxRelay = new RelayCommand(AddParameterComboBox);
+        AddCommandComboBoxRelay = new RelayCommand(AddCommandComboBox);
+        RemoveParameterComboBoxRelay = new RelayCommand(RemoveParameterComboBox);
+        SaveCustomQueriesRelay = new RelayCommand(SaveCustomQueries);
+        EditCustomQueryRelay = new RelayCommand(EditCustomQuery);
+        DeleteCustomQueryRelay = new RelayCommand(DeleteCustomQuery);
+        // TODO: Rename below property and method!!!
+        ExecuteCommandButtonRelay = new RelayCommand(ExecuteCustomQueryCommandButton);
+
+        InitializeActiveDirectoryCommandsAsync();
+        LoadCustomQueries(); // Calls method to deserialize and load buttons.
+
+        // Debug
+        foreach (Button t in QueryButtonStackPanel)
+        {
+            CustomQueries.Query test = (CustomQueries.Query)t.Tag;
+            Trace.WriteLine(test.CommandName);
+        }
+    }
+
+    // [ Methods ] ----------------------------------------------------------------- //
+
+    /// <summary>
+    /// This method will edit the Query and fill out the field with the desired query and you can edit the query
+    /// </summary>
+    /// <note>
+    /// This method is of scope internal because it is tested in the test project, but should remain private.
+    /// </note>
+    /// <param name="sender">This is the object that is clicked when executing</param>
+    private void EditCustomQuery(object sender)
+    {
+        // Get the button that we are editing
+        Button currButton = (Button)sender;
+        CustomQueries.Query currQuery = (CustomQueries.Query)currButton.Tag;
+
+        _isEditing = currQuery;
+
+        // Need to fill in the queryName
+        QueryName = currQuery.QueryName;
+
+        // Fill in the queryDescription
+        QueryDescription = currQuery.QueryDescription;
+
+        // Fill in the commandName
+        Command chosenCommand =
+            ActiveDirectoryCommandsList.FirstOrDefault(item => item.CommandText == currQuery.CommandName)!;
+        SelectedComboBoxCommand = chosenCommand;
+
+        // Load the Possible Parameters Synchronously
+        CommandParameters commandParameters = new CommandParameters();
+        ((ICommandParameters)commandParameters).LoadCommandParameters(SelectedComboBoxCommand);
+        PossibleCommandParametersList = new ObservableCollection<string>(commandParameters.PossibleParameters);
+        OnPropertyChanged(nameof(PossibleCommandParametersList));
+
+        // Check to see if the DynamicParametersCollection is empty and clear it if it is
+        if (DynamicParametersCollection.Count != 0)
+        {
+            DynamicParametersCollection.Clear();
+            DynamicParameterValuesCollection.Clear();
+        }
+
+        // Fill in Parameters and values
+        for (int i = 0; i < currQuery.CommandParameters.Length; i++)
+        {
+            Trace.WriteLine(currQuery.CommandParameters[i]);
+
+            // Adds the Parameters boxes
+            object temp = new();
+            AddParameterComboBox(temp);
+
+            // Fill in the parameter boxes
+            DynamicParametersCollection[i].SelectedParameter = currQuery.CommandParameters[i];
+            DynamicParameterValuesCollection[i].SelectedParameterValue = currQuery.CommandParametersValues[i];
+        }
+    }
+
+    /// <summary>
+    /// This method executes the CustomQuery.query.command that is tied to the custom query buttons
+    /// </summary>
+    /// <param name="_">This is the Button as a generic object that is clicked when executing</param>
+    private async void ExecuteCustomQueryCommandButton(object _)
+    {
+        var currentButton = _ as Button;
+
+        if (currentButton is null)
+        {
+            return;
+        }
+
+        CustomQueries.Query buttonQuery = (CustomQueries.Query)currentButton.Tag;
+        await ExecuteGenericCommand(buttonQuery.Command);
+    }
+
+    /// <summary>
+    /// This method deletes the button from the list and saves the changes to the file
+    /// </summary>
+    /// <param name="_">This is the Button as a generic object that is clicked when executing</param>
+    private void DeleteCustomQuery(object _)
+    {
+        // Delete a button from the custom queries list and from the file
+        var currentButton = _ as Button;
+
+        if (currentButton is null)
+        {
+            return;
+        }
+
+        QueryButtonStackPanel.Remove(currentButton);
+        _customQuery.Queries.Remove((CustomQueries.Query)currentButton.Tag);
+        _customQuery.SerializeMethod();
+    }
+
+    /// <summary>
+    /// This method will load the custom queries from the file.
+    /// TODO: Remove any unused variables.
+    /// </summary>
+    private void LoadCustomQueries()
+    {
+        try
+        {
+            // Load the custom queries from the file (Deserialize)
+            _customQuery.LoadData();
+
+            // Loop through the queries and create a button for each one
+            foreach (CustomQueries.Query cQuery in _customQuery.Queries)
+            {
+                // Creates a new button for each query
+                Button newButton = CreateCustomButton(cQuery);
+
+                // Lastly add the button to the stack panel
+                QueryButtonStackPanel.Add(newButton);
+            }
+        }
+        catch (Exception ex)
+        {
+            Trace.WriteLine(ex);
+        }
+    }
+
+    /// <summary>
+    /// Executes the selected PowerShell command asynchronously.
+    /// </summary>
+    /// <param name="_">Parameter is not used, but required for the ICommand interface.</param>
+    private async void ExecuteCommandAsync(object _)
+    {
+        await ExecuteSelectedCommandAsync();
+    }
+
+    /// <summary>
+    /// Initializes the list of Active Directory commands asynchronously.
+    /// </summary>
+    private async Task InitializeActiveDirectoryCommandsAsync()
+    {
+        ObservableCollection<Command> list = await ActiveDirectoryCommands.GetActiveDirectoryCommands();
+        ActiveDirectoryCommandsList = new(list);
+        OnPropertyChanged(nameof(ActiveDirectoryCommandsList));
+    }
+
+    /// <summary>
+    /// Loads the parameters for the selected PowerShell command asynchronously.
+    /// </summary>
+    /// <param name="selectedCommand">The PowerShell command whose parameters are to be loaded.</param>
+    private async Task LoadCommandParametersAsync(Command? selectedCommand)
+    {
+        CommandParameters commandParameters = new();
+        await commandParameters.LoadCommandParametersAsync(selectedCommand);
+        PossibleCommandParametersList = new ObservableCollection<string>(commandParameters.PossibleParameters);
+        OnPropertyChanged(nameof(PossibleCommandParametersList));
+
+        // Update the possible properties of the ComboBoxParameterViewModels.
+        foreach (ComboBoxParameterViewModel comboBoxParameterViewModel in DynamicParametersCollection)
+        {
+            comboBoxParameterViewModel.PossibleParameterList = PossibleCommandParametersList;
+        }
+    }
+
+    /// <summary>
+    /// Executes the currently selected PowerShell command and updates the PowerShellOutput property with the result.
+    /// </summary>
+    /// <returns>A Task representing the asynchronous operation of executing the command.</returns>
+    private async Task ExecuteSelectedCommandAsync()
+    {
+        if (SelectedComboBoxCommand is null)
+        {
+            Trace.WriteLine("No command selected.");
+            MessageBox.Show("To execute a command, you must first select a command.",
+                            "Warning",
+                            MessageBoxButton.OK,
+                            MessageBoxImage.Warning);
+            return;
+        }
+
+        try
+        {
+            // Add selected parameters and their values to the command.
+            for (int i = 0; i < DynamicParametersCollection.Count; i++)
+            {
+                string parameterName = DynamicParametersCollection[i].SelectedParameter;
+                string parameterValue = DynamicParameterValuesCollection[i].SelectedParameterValue;
+                SelectedComboBoxCommand.Parameters.Add(new CommandParameter(parameterName, parameterValue));
+            }
+
+            ReturnValues result = await _powerShellExecutor.ExecuteAsync(SelectedComboBoxCommand);
+
+            if (result.HadErrors)
+            {
+                PowerShellOutput = string.Join(Environment.NewLine, result.StdErr);
+                return;
+            }
+
+            PowerShellOutput = string.Join(Environment.NewLine, result.StdOut);
+        }
+        catch (Exception ex)
+        {
+            PowerShellOutput = $"Error executing command: {ex.Message}";
+        }
+    }
+
+    /// <summary>
+    /// Executes the inputted Command PowerShell command and updates the PowerShellOutput property with the result.
+    /// TODO: Rename this method...
+    /// TODO: Does this method do the same thing an another method???
+    /// </summary>
+    /// <param name="toBeExecuted">This is the command to be executed</param>
+    /// <returns>A Task representing the asynchronous operation of executing the command.</returns>
+    private async Task ExecuteGenericCommand(Command? toBeExecuted)
+    {
+        try
+        {
+            // Execute the command
+            ReturnValues result = await _powerShellExecutor.ExecuteAsync(toBeExecuted);
+            // Error handling
+            if (result.HadErrors)
+            {
+                PowerShellOutput = string.Join(Environment.NewLine, result.StdErr);
+                return;
+            }
+
+            PowerShellOutput = string.Join(Environment.NewLine, result.StdOut);
+        }
+        catch (Exception ex)
+        {
+            PowerShellOutput = $"Error executing command: {ex.Message}";
+        }
+    }
+
+    /// <summary>
+    /// Adds a new parameter and value selection ComboBox to the DynamicParametersCollection.
+    /// </summary>
+    /// <param name="_">This is the object that the command is bound to</param>
+    private void AddParameterComboBox(object _)
+    {
+        // Check if some variable is null and throw an exception if it is
+        if (PossibleCommandParametersList is null)
+        {
+            Trace.WriteLine("PossibleCommandParametersList has not been populated yet.");
+            MessageBox.Show("To add a parameter, you must first select a command.",
+                            "Warning",
+                            MessageBoxButton.OK,
+                            MessageBoxImage.Warning);
+            return;
+        }
+
+        DynamicParametersCollection.Add(new ComboBoxParameterViewModel(PossibleCommandParametersList));
+        DynamicParameterValuesCollection.Add(new TextBoxViewModel());
+    }
+
+    /// <summary>
+    /// TODO: Add a summary.
+    /// </summary>
+    /// <param name="_">This is the object that the command is bound to.</param>
+    private void AddCommandComboBox(object _)
+    {
+        // throw new NotImplementedException();
+        Trace.WriteLine("Not implemented yet.");
+        MessageBox.Show("Not implemented yet.", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+    }
+
+    /// <summary>
+    /// This method executes the currently selected command and saves the output to a text file.
+    /// </summary>
+    /// <param name="_">Represents the object that the command is bound to.</param>
+    private async void OutputToTextFileAsync(object _)
+    {
+        await ExecuteSelectedCommandAsync();
+
+        // Filepath
+        // Write the text to a file & prompt user for the location
+
+        SaveFileDialog saveFileDialog = new() {                       // Set properties of the OpenFileDialog
+                                               FileName = "Document", // Default file name
+                                               Filter = "All files(*.*) | *.*"
+        };
+
+        // Display
+        bool? result = saveFileDialog.ShowDialog();
+
+        // Get file and write text
+        if (result == true)
+        {
+            // Open document
+            string filePath = saveFileDialog.FileName;
+            await File.WriteAllTextAsync(filePath, PowerShellOutput);
+        }
+    }
+
+    /// <summary>
+    /// This method is in the working
+    /// Status: prompts user for file path and saves correctly though the string could be edited to be better
+    /// </summary>
+    /// <param name="_">Represents the object that the command is bound to</param>
+    private async void OutputToCsvFileAsync(object _)
+    {
+        await ExecuteSelectedCommandAsync();
+
+        var csv = new StringBuilder();
+        string[] output = PowerShellOutput.Split(' ', '\n');
+
+        for (int i = 0; i < output.Length - 2; i++)
+        {
+            var first = output[i];
+            var second = output[i + 1];
+            // format the strings and add them to a string
+            var newLine = $"{first},{second}";
+            csv.AppendLine(newLine);
+        }
+
+        // Write the text to a file & prompt user for the location
+        SaveFileDialog saveFileDialog = new() { FileName = "Document", Filter = "All files(*.*) | *.*" };
+
+        // Display
+        bool? result = saveFileDialog.ShowDialog();
+
+        // Get file and write text
+        if (result == true)
+        {
+            // Open document
+            string filePath = saveFileDialog.FileName;
+            await File.WriteAllTextAsync(filePath, csv.ToString());
+        }
+    }
+
+    /// <summary>
+    /// This method is for getting the currently selected command at anytime
+    /// TODO: !Still in the works!
+    /// TODO: Remove any unused variables.
+    /// TODO: Does this method do the same thing an another method???
+    /// </summary>
+    private void UpdateSelectedCommand()
+    {
+        if (SelectedComboBoxCommand is null)
+        {
+            Trace.WriteLine("No command selected.");
+            MessageBox.Show("To save a query, you must first select a command.",
+                            "Warning",
+                            MessageBoxButton.OK,
+                            MessageBoxImage.Warning);
+            return;
+        }
+
+        // Try to get the content within the drop downs
+        try
+        {
+            for (int i = 0; i < DynamicParametersCollection.Count; i++)
+            {
+                SelectedComboBoxCommand.Parameters.Add(
+                    new CommandParameter(DynamicParametersCollection[i].SelectedParameter,
+                                         DynamicParameterValuesCollection[i].SelectedParameterValue));
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.Write(ex);
+        }
+    }
+
+    /// <summary>
+    /// Updates the _currentQuery object with the current query information.
+    /// TODO: It needs to be tested! Still in the works!
+    /// TODO: Fix any and all warnings about possible null values.
+    /// </summary>
+    private void GetCurrentQuery()
+    {
+        // Update the selected command
+        UpdateSelectedCommand();
+
+        try
+        {
+            string[] commandParameters = new string[SelectedComboBoxCommand.Parameters.Count];
+            string[] commandParameterValues = new string[SelectedComboBoxCommand.Parameters.Count];
+
+            _currentQuery.QueryDescription = QueryDescription;
+            _currentQuery.QueryName = QueryName;
+
+            _currentQuery.CommandName = SelectedComboBoxCommand.CommandText;
+
+            int i = 0;
+            foreach (CommandParameter commandParameter in SelectedComboBoxCommand.Parameters)
+            {
+                commandParameters[i] = commandParameter.Name;
+                commandParameterValues[i] = commandParameter.Value.ToString();
+                i++;
+            }
+            _currentQuery.CommandParameters = commandParameters;
+            _currentQuery.CommandParametersValues = commandParameterValues;
+        }
+        catch (Exception ex)
+        {
+            Trace.WriteLine(ex);
+        }
+    }
+
+    /// <summary>
+    /// Removes the parameter box after adding them
+    /// </summary>
+    /// <param name="_">This is the CommandParameter object that this command is tied to</param>
+    private void RemoveParameterComboBox(object _)
+    {
+        if (DynamicParametersCollection.Count != 0)
+        {
+            DynamicParametersCollection.RemoveAt(DynamicParametersCollection.Count - 1);
+            DynamicParameterValuesCollection.RemoveAt(DynamicParameterValuesCollection.Count - 1);
+        }
+    }
+
+    /// <summary>
+    /// This method will serialize the command and add it to the list of buttons.
+    /// TODO: Fix any and all warnings about possible null values.
+    /// TODO: Remove any unused variables.
+    /// </summary>
+    /// <param name="commandParameter">This is not used but necessary for the relay command</param>
+    private void SaveCustomQueries(object commandParameter)
+    {
+        if (SelectedComboBoxCommand is null)
+        {
+            Trace.WriteLine("No command selected.");
+            MessageBox.Show("To save a query, you must first select a command.",
+                            "Warning",
+                            MessageBoxButton.OK,
+                            MessageBoxImage.Warning);
+            return;
+        }
+
+        if (_isEditing is not null)
+        {
+            // CustomQueries.query editingQuery = _customQuery.Queries.Find(item => item == isEditing);
+            GetCurrentQuery();
+            _customQuery.Queries[_customQuery.Queries.IndexOf(_isEditing)] = _currentQuery;
+            _customQuery.SerializeMethod();
+            _isEditing = null;
+        }
+        else
+        {
+            // Try to get the content within the drop downs
+            try
+            {
+                int i = 0;
+                foreach (var comboBoxData in DynamicParametersCollection)
+                {
+                    // string selectedItem = comboBoxData.SelectedParameter;
+                    // Need to look at this to see if it is working with the object type and then serialize it
+                    // Trace.WriteLine(DynamicParameterValuesCollection[i].SelectedParameterValue);
+
+                    SelectedComboBoxCommand.Parameters.Add(
+                        new CommandParameter(comboBoxData.SelectedParameter,
+                                             DynamicParameterValuesCollection[i].SelectedParameterValue));
+                    i++;
+                }
+
+                _customQuery.SerializeCommand(SelectedComboBoxCommand, QueryName, QueryDescription);
+
+                Button newButton = CreateCustomButton();
+
+                QueryButtonStackPanel.Add(newButton);
+            }
+            catch (Exception ex)
+            {
+                Console.Write(ex);
+            }
+        }
+    }
+
+    /// <summary>
+    /// This method is for creating buttons, right now it creates it off of the current/selectedcommand parameters but
+    /// could be changed to also do it from the query list.
+    /// TODO: Change method name???
+    /// </summary>
+    /// <returns>This method returns a button that has been customized for the custom query list</returns>
+    private Button CreateCustomButton(CustomQueries.Query query = null)
+    {
+        GetCurrentQuery();
+
+        if (SelectedComboBoxCommand is null)
+        {
+            Trace.WriteLine("No command selected.");
+            MessageBox.Show("To save a query, you must first select a command.",
+                            "Warning",
+                            MessageBoxButton.OK,
+                            MessageBoxImage.Warning);
+            return null; // TODO: Figure out what to return here!!!
+        }
+
+        Button newButton = new Button();
+
+        if (query != null)
+        {
+            newButton.Height = 48;
+            newButton.Content = query.QueryName ?? query.CommandName;
+            newButton.Tag = query;
+        }
+        else
+        {
+            newButton.Height = 48;
+            newButton.Content = QueryName.Length != 0 ? QueryName : SelectedComboBoxCommand.CommandText;
+            newButton.Tag = _currentQuery;
+        }
+
+        // Button newButton =
+        // new() { Height = 48, Content = QueryName.Length != 0 ? QueryName : SelectedComboBoxCommand.CommandText, Tag =
+        // _currentQuery };
+
+        // Want to add right click context menu to each button
+        ContextMenu contextMenu = new();
+
+        MenuItem menuItem1 =
+            new() { Header = "Execute", Command = ExecuteCommandButtonRelay, CommandParameter = newButton };
+
+        MenuItem menuItem2 = new() { Header = "Edit", Command = EditCustomQueryRelay, CommandParameter = newButton };
+
+        MenuItem menuItem3 =
+            new() { Header = "Delete", Command = DeleteCustomQueryRelay, CommandParameter = newButton };
+
+        // Add menu item to the context menu
+        contextMenu.Items.Add(menuItem1);
+        contextMenu.Items.Add(menuItem2);
+        contextMenu.Items.Add(menuItem3);
+
+        // Add the context menu to the button
+        newButton.ContextMenu = contextMenu;
+        return newButton;
+    }
+
+    // [[ Event Handlers ]] --------------------------------------------------------- //
+
+    /// <summary>
+    /// Handles property change notifications.
+    /// </summary>
+    /// <param name="propertyName">Name of the property that changed.</param>
+    private void OnPropertyChanged(string propertyName)
+    {
+        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+    }
+}
diff --git a/ActiveDirectoryQuerier/PSSaveOptions.cs b/ActiveDirectoryQuerier/PSSaveOptions.cs
new file mode 100644
index 0000000..e089b42
--- /dev/null
+++ b/ActiveDirectoryQuerier/PSSaveOptions.cs
@@ -0,0 +1,45 @@
+using System.Management.Automation.Internal;
+using System.Management.Automation.Runspaces;
+using ActiveDirectoryQuerier.PowerShell;
+
+namespace ActiveDirectoryQuerier;
+
+/// <summary>
+/// This class *might* be used for housing the save options
+/// TODO: Delete this class if it is not used...
+/// </summary>
+public class PSSaveOptions
+{
+    /// <summary>
+    /// This would be to output the query to a csv, will need to eventually adapt to a guicommand as well most likely
+    /// </summary>
+    /// <param name="commandString"> This is the internal command that we want to output to a csv </param>
+    public Command OutputToCsv(Command commandString)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// This would be to have the query output to a message box
+    /// </summary>
+    public InternalCommand OutputToMessageBox(InternalCommand commandSting)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// This will be to save the query to a text file
+    /// </summary>
+    public void SaveToTxt(ReturnValues results)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// This is used for saving the file to a PS1 powershell file
+    /// </summary>
+    public void SaveToPS(ReturnValues results)
+    {
+        throw new NotImplementedException();
+    }
+}
diff --git a/FAFB-PowerShell-Tool/PowerShell/ActiveDirectoryCommands.cs b/ActiveDirectoryQuerier/PowerShell/ActiveDirectoryCommands.cs
similarity index 85%
rename from FAFB-PowerShell-Tool/PowerShell/ActiveDirectoryCommands.cs
rename to ActiveDirectoryQuerier/PowerShell/ActiveDirectoryCommands.cs
index bbdfce9..7dfbdc1 100644
--- a/FAFB-PowerShell-Tool/PowerShell/ActiveDirectoryCommands.cs
+++ b/ActiveDirectoryQuerier/PowerShell/ActiveDirectoryCommands.cs
@@ -1,8 +1,9 @@
 using System.Collections.ObjectModel;
 using System.Management.Automation;
 using System.Management.Automation.Runspaces;
+using System.Windows;
 
-namespace FAFB_PowerShell_Tool.PowerShell;
+namespace ActiveDirectoryQuerier.PowerShell;
 
 /// <summary>
 /// Provides functionalities related to the ActiveDirectory PowerShell module.
@@ -25,12 +26,15 @@ public static async Task<ObservableCollection<Command>> GetActiveDirectoryComman
         PowerShellExecutor powerShellExecutor = new();
         ObservableCollection<Command> commandList = new();
         ReturnValues commandListTemp = await powerShellExecutor.ExecuteAsync(command);
-        
+
         // NOTE: This is more of an internal error...
         // TODO: Provide a more detailed error message??? Maybe log the error to a file???
         if (commandListTemp.HadErrors)
         {
-            MessageBoxOutput.Show(string.Join(" ", commandListTemp.StdErr), MessageBoxOutput.OutputType.Error);
+            MessageBox.Show(string.Join(" ", commandListTemp.StdErr),
+                            "Warning",
+                            MessageBoxButton.OK,
+                            MessageBoxImage.Error);
             throw new InvalidPowerShellStateException(
                 "An error occurred while retrieving the ActiveDirectory commands.");
         }
diff --git a/ActiveDirectoryQuerier/PowerShell/CommandParameters.cs b/ActiveDirectoryQuerier/PowerShell/CommandParameters.cs
new file mode 100644
index 0000000..60fe965
--- /dev/null
+++ b/ActiveDirectoryQuerier/PowerShell/CommandParameters.cs
@@ -0,0 +1,103 @@
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.Management.Automation;
+using System.Management.Automation.Runspaces;
+
+namespace ActiveDirectoryQuerier.PowerShell;
+
+/// <summary>
+/// Manages and provides the parameters available for a given PowerShell command.
+/// TODO: Figure out what to do with the Async and non-Async methods! Too much duplicate code..
+/// </summary>
+public class CommandParameters : ICommandParameters
+{
+    private readonly ObservableCollection<string> _possibleParameters = new();
+
+    /// <summary>
+    /// Gets the collection of possible parameters for a command.
+    /// </summary>
+    /// <note>
+    /// I realize that this isn't a very clean way of doing things, but it's the best I could come up with at the time.
+    /// </note>
+    /// <exception cref="InvalidOperationException">Thrown when the collection has not been populated yet.</exception>
+    public ObservableCollection<string> PossibleParameters
+    {
+        get {
+            if (_possibleParameters.Count == 0)
+            {
+                throw new InvalidOperationException(
+                    "'PossibleParameters' has not been populated via 'LoadCommandParametersAsync'.");
+            }
+
+            return _possibleParameters;
+        }
+    }
+
+    /// <summary>
+    /// Asynchronously loads the possible parameters for the specified command into the '_possibleParameters'
+    /// collection.
+    /// </summary>
+    /// <param name="commandObject">The PowerShell command object whose parameters are to be loaded.</param>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    public async Task LoadCommandParametersAsync(Command? commandObject)
+    {
+        // commandObject can be null if the user attempts to select an ActiveDirectory command that doesn't exist.
+        // More specifically, if the entered command doesn't exist in the ActiveDirectoryCommandsList in
+        // MainWindowViewModel.cs, commandObject will be null, causing an exception to be thrown, crashing the program.
+        if (commandObject is null)
+        {
+            Trace.WriteLine("Error: commandObject is null");
+            _possibleParameters.Add("No valid command provided");
+            return;
+        }
+
+        if (_possibleParameters.Count == 0)
+        {
+            using var powerShell = System.Management.Automation.PowerShell.Create();
+            string commandString =
+                $"Get-Command {commandObject.CommandText} | Select -ExpandProperty Parameters | ForEach-Object {{ $_.Keys }}";
+
+            powerShell.Commands.Clear();
+            powerShell.AddScript(commandString);
+            PSDataCollection<PSObject> result = await powerShell.InvokeAsync();
+
+            foreach (PSObject cmd in result)
+            {
+                _possibleParameters.Add($"-{cmd}");
+            }
+        }
+    }
+
+    /// <summary>
+    /// Loads the possible parameters for the specified command into the '_possibleParameters' collection.
+    /// </summary>
+    /// <param name="commandObject">The PowerShell command object whose parameters are to be loaded.</param>
+    void ICommandParameters.LoadCommandParameters(Command? commandObject)
+    {
+        // commandObject can be null if the user attempts to select an ActiveDirectory command that doesn't exist.
+        // More specifically, if the entered command doesn't exist in the ActiveDirectoryCommandsList in
+        // MainWindowViewModel.cs, commandObject will be null, causing an exception to be thrown, crashing the program.
+        if (commandObject is null)
+        {
+            Trace.WriteLine("Error: commandObject is null");
+            _possibleParameters.Add("No valid command provided");
+            return;
+        }
+
+        if (_possibleParameters.Count == 0)
+        {
+            using var powerShell = System.Management.Automation.PowerShell.Create();
+            string commandString =
+                $"Get-Command {commandObject.CommandText} | Select -ExpandProperty Parameters | ForEach-Object {{$_.Keys }}";
+
+            powerShell.Commands.Clear();
+            powerShell.AddScript(commandString);
+            Collection<PSObject> result = powerShell.Invoke();
+
+            foreach (PSObject cmd in result)
+            {
+                _possibleParameters.Add($"-{cmd}");
+            }
+        }
+    }
+}
diff --git a/ActiveDirectoryQuerier/PowerShell/CustomQueries.cs b/ActiveDirectoryQuerier/PowerShell/CustomQueries.cs
new file mode 100644
index 0000000..cd2114d
--- /dev/null
+++ b/ActiveDirectoryQuerier/PowerShell/CustomQueries.cs
@@ -0,0 +1,182 @@
+using System.Diagnostics;
+using System.IO;
+using System.Management.Automation.Runspaces;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace ActiveDirectoryQuerier.PowerShell;
+
+/// <summary>
+/// This class is used to save a json file named "CustomQueries.dat" inside of
+/// \ActiveDirectoryQuerier\ActiveDirectoryQuerier\bin\Debug\net6.0-windows This
+/// </summary>
+internal class CustomQueries
+{
+    public class Query
+    {
+        /// <summary>
+        /// Command that should help with Binding the command to the query for the buttons sake
+        /// </summary>
+        [JsonIgnore]
+        public Command? Command { get; set; }
+
+        /// <summary>
+        /// Used for serializing the Command Name
+        /// </summary>
+        public string CommandName { get; set; }
+
+        /// <summary>
+        /// Used for Serializing the Commands parameters
+        /// </summary>
+        public string[] CommandParameters { get; set; }
+
+        /// <summary>
+        /// Used for Serializing the Commands parameters
+        /// </summary>
+        public string[] CommandParametersValues { get; set; }
+
+        /// <summary>
+        /// Used for the name of the custom Query
+        /// </summary>
+        public string QueryName { get; set; }
+
+        /// <summary>
+        /// Used for the Custom Queries Description
+        /// </summary>
+        public string QueryDescription { get; set; }
+
+        // Constructor for the query class
+        /*public Query(string cN, string[] commandParams)
+        {
+            this.CommandName = cN;
+            this.CommandParameters = commandParams;
+        }*/
+
+        /// <summary>
+        /// Constructor for the query class
+        /// TODO: Fix any and all warnings about possible null values.
+        /// </summary>
+        /// <param name="cN"></param>
+        public Query(string cN)
+        {
+            CommandName = cN;
+        }
+
+        /// <summary>
+        /// Empty constructor for the query class
+        /// TODO: Fix any and all warnings about possible null values.
+        /// </summary>
+        public Query()
+        { }
+    }
+
+    public List<Query> Queries = new();
+
+    /// <summary>
+    /// This a variable for feeding options to the Json serializer
+    /// </summary>
+    private static readonly JsonSerializerOptions _options = new() {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        WriteIndented = true,
+        ReferenceHandler = ReferenceHandler.Preserve,
+    };
+
+    /// <summary>
+    /// This takes the Queries List and serializes it to a file
+    /// </summary>
+    public void SerializeMethod()
+    {
+        try
+        {
+            string json = JsonSerializer.Serialize(Queries, _options);
+            File.WriteAllText("CustomQueries.dat", json);
+        }
+        catch (Exception ex)
+        {
+            Trace.WriteLine(ex);
+        }
+    }
+
+    /// <summary>
+    /// This method is for serializing a command type, so it converts the type to a query and then serializes it
+    /// TODO: Fix any and all warnings about possible null values.
+    /// </summary>
+    public void SerializeCommand(Command? cmnd, string queryName, string queryDescription)
+    {
+        Trace.WriteLine(cmnd.Parameters.Count);
+
+        string[] commandParameters = new string[cmnd.Parameters.Count];
+        string[] commandParameterValues = new string[cmnd.Parameters.Count];
+        Query newQuery = new Query(cmnd.CommandText);
+
+        // Set name and description
+        newQuery.QueryName = queryName;
+        newQuery.QueryDescription = queryDescription;
+
+        // Iterate over the parameters and add them to the string
+
+        for (int i = 0; i < cmnd.Parameters.Count; i++)
+        {
+            CommandParameter param = cmnd.Parameters[i];
+
+            Trace.WriteLine(param.Name + " Value: ");
+
+            commandParameters[i] = param.Name;
+            commandParameterValues[i] = param.Value.ToString();
+        }
+        newQuery.CommandParameters = commandParameters;
+        newQuery.CommandParametersValues = commandParameterValues;
+
+        Queries.Add(newQuery);
+
+        CustomQueries customQueries = new CustomQueries();
+        customQueries.SerializeMethod();
+        try
+        {
+            string json = JsonSerializer.Serialize(Queries, _options);
+            Trace.WriteLine(json);
+            File.WriteAllText("CustomQueries.dat", json);
+        }
+        catch (Exception ex)
+        {
+            Trace.WriteLine(ex);
+        }
+    }
+    /// <summary>
+    /// This method Loads the string from the saved file "CustomQueries.dat" then gives it to the Queries List
+    /// TODO: Fix any and all warnings about possible null values.
+    /// </summary>
+    public void LoadData()
+    {
+        try
+        {
+            // Opens file and reads it then adds the json to the Queries List
+            string json = File.ReadAllText("CustomQueries.dat");
+            Queries = JsonSerializer.Deserialize<List<Query>>(json, _options);
+
+            // Now we want to fill the command variable for each query
+            foreach (Query q in Queries)
+            {
+                Command? command = new Command(q.CommandName);
+
+                // Check if there are parameters, and if there are add them to the list
+                if (q.CommandParameters != null)
+                {
+                    for (int i = 0; i < q.CommandParameters.Length; i++)
+                    {
+                        // command.Parameters.Add(q.commandParameters[i], q.commandParametersValues[i]);  -- Once
+                        // the values are working then we will use this
+                        command.Parameters.Add(q.CommandParameters[i]);
+                    }
+                }
+
+                // set the query command to the command
+                q.Command = command;
+            }
+        }
+        catch (Exception ex)
+        {
+            Trace.WriteLine(ex);
+        }
+    }
+}
diff --git a/ActiveDirectoryQuerier/PowerShell/ICommandParameters.cs b/ActiveDirectoryQuerier/PowerShell/ICommandParameters.cs
new file mode 100644
index 0000000..d765e23
--- /dev/null
+++ b/ActiveDirectoryQuerier/PowerShell/ICommandParameters.cs
@@ -0,0 +1,8 @@
+using System.Management.Automation.Runspaces;
+
+namespace ActiveDirectoryQuerier.PowerShell;
+
+public interface ICommandParameters
+{
+    void LoadCommandParameters(Command? commandObject);
+}
diff --git a/FAFB-PowerShell-Tool/PowerShell/PowerShellExecutor.cs b/ActiveDirectoryQuerier/PowerShell/PowerShellExecutor.cs
similarity index 75%
rename from FAFB-PowerShell-Tool/PowerShell/PowerShellExecutor.cs
rename to ActiveDirectoryQuerier/PowerShell/PowerShellExecutor.cs
index f4333cc..ed9fff7 100644
--- a/FAFB-PowerShell-Tool/PowerShell/PowerShellExecutor.cs
+++ b/ActiveDirectoryQuerier/PowerShell/PowerShellExecutor.cs
@@ -4,7 +4,7 @@
 using System.Management.Automation.Runspaces;
 using System.Text;
 
-namespace FAFB_PowerShell_Tool.PowerShell;
+namespace ActiveDirectoryQuerier.PowerShell;
 
 /// <summary>
 /// Manages execution of PowerShell commands, providing both synchronous and asynchronous execution methods.
@@ -29,8 +29,14 @@ public PowerShellExecutor()
     /// Prepares a PowerShell command for execution.
     /// </summary>
     /// <param name="command">The command to be prepared for execution.</param>
-    private void PrepareCommand(Command command)
+    private void PrepareCommand(Command? command)
     {
+        // TODO: Might change to just return if command is null...
+        if (command is null)
+        {
+            throw new ArgumentNullException(nameof(command));
+        }
+
         _powerShell.Commands.AddCommand(command.CommandText);
         foreach (var parameter in command.Parameters)
         {
@@ -43,23 +49,19 @@ private void PrepareCommand(Command command)
     /// </summary>
     /// <param name="command">The command to be executed.</param>
     /// <returns>A ReturnValues object containing the results of the command execution.</returns>
-    public ReturnValues Execute(Command command)
+    public ReturnValues Execute(Command? command)
     {
         try
         {
             PrepareCommand(command);
 
             Collection<PSObject> results = _powerShell.Invoke();
+
             return ProcessPowerShellResults(results);
         }
         catch (Exception ex)
         {
-            StringBuilder sb = new();
-            sb.AppendLine("An error occurred while executing the PowerShell command:");
-            sb.AppendLine(ex.Message);
-            sb.AppendLine(ex.StackTrace);
-            Debug.WriteLine(sb.ToString());
-            return new ReturnValues { StdErr = { sb.ToString() } };
+            return ExecutionExceptionHandler(ex);
         }
     }
 
@@ -68,26 +70,39 @@ public ReturnValues Execute(Command command)
     /// </summary>
     /// <param name="command">The command to be executed.</param>
     /// <returns>A task containing a ReturnValues object with the results of the command execution.</returns>
-    public async Task<ReturnValues> ExecuteAsync(Command command)
+    public async Task<ReturnValues> ExecuteAsync(Command? command)
     {
         try
         {
             PrepareCommand(command);
 
             PSDataCollection<PSObject> results = await _powerShell.InvokeAsync();
+
             return await ProcessPowerShellResultsAsync(results);
         }
         catch (Exception ex)
         {
-            StringBuilder sb = new();
-            sb.AppendLine("An error occurred while executing the PowerShell command:");
-            sb.AppendLine(ex.Message);
-            sb.AppendLine(ex.StackTrace);
-            Debug.WriteLine(sb.ToString());
-            return new ReturnValues { StdErr = { sb.ToString() } };
+            return ExecutionExceptionHandler(ex);
         }
     }
 
+    /// <summary>
+    /// Handles exceptions that occur during the execution of a PowerShell command.
+    /// </summary>
+    /// <param name="ex">The exception that occurred during the execution of the PowerShell command.</param>
+    /// <returns>A ReturnValues object containing the exception details.</returns>
+    private ReturnValues ExecutionExceptionHandler(Exception ex)
+    {
+        StringBuilder sb = new();
+
+        sb.AppendLine("An error occurred while executing the PowerShell command:");
+        sb.AppendLine(ex.Message);
+        sb.AppendLine(ex.StackTrace);
+        Debug.WriteLine(sb.ToString());
+
+        return new ReturnValues { StdErr = { sb.ToString() } };
+    }
+
     /// <summary>
     /// Processes and formats the results of a PowerShell command execution synchronously.
     /// </summary>
diff --git a/FAFB-PowerShell-Tool/PowerShell/ReturnValues.cs b/ActiveDirectoryQuerier/PowerShell/ReturnValues.cs
similarity index 95%
rename from FAFB-PowerShell-Tool/PowerShell/ReturnValues.cs
rename to ActiveDirectoryQuerier/PowerShell/ReturnValues.cs
index 2141750..afcad90 100644
--- a/FAFB-PowerShell-Tool/PowerShell/ReturnValues.cs
+++ b/ActiveDirectoryQuerier/PowerShell/ReturnValues.cs
@@ -1,4 +1,4 @@
-namespace FAFB_PowerShell_Tool.PowerShell;
+namespace ActiveDirectoryQuerier.PowerShell;
 
 /// <summary>
 /// Encapsulates the return values from a PowerShell command, separated into standard output (StdOut) and standard
diff --git a/FAFB-PowerShell-Tool/RelayCommand.cs b/ActiveDirectoryQuerier/RelayCommand.cs
similarity index 79%
rename from FAFB-PowerShell-Tool/RelayCommand.cs
rename to ActiveDirectoryQuerier/RelayCommand.cs
index 231b3c5..29ddc36 100644
--- a/FAFB-PowerShell-Tool/RelayCommand.cs
+++ b/ActiveDirectoryQuerier/RelayCommand.cs
@@ -1,13 +1,17 @@
 using System.Windows.Input;
 
-namespace FAFB_PowerShell_Tool;
+namespace ActiveDirectoryQuerier;
 
 /// <summary>
 /// A command whose sole purpose is to relay its functionality to other objects by invoking delegates.
+/// TODO: Remove any unused methods, after some investigation.
 /// </summary>
+/// <note>
+/// I'm unsure if I'm dealing with the nullability warnings correctly, in this situation...
+/// </note>
 public class RelayCommand : ICommand
 {
-    private readonly Action<object?> _execute;
+    private readonly Action<object> _execute;
     private readonly Predicate<object?>? _canExecute;
 
     /// <summary>
@@ -16,9 +20,9 @@ public class RelayCommand : ICommand
     /// <param name="execute">The execution logic.</param>
     /// <param name="canExecute">The execution status logic.</param>
     /// <exception cref="ArgumentNullException">If the execute argument is null.</exception>
-    public RelayCommand(Action<object?> execute, Predicate<object?>? canExecute = null)
+    public RelayCommand(Action<object> execute, Predicate<object?>? canExecute = null)
     {
-        _execute = execute ?? throw new ArgumentNullException(nameof(execute));
+        _execute = execute;
         _canExecute = canExecute;
     }
 
@@ -42,7 +46,8 @@ public bool CanExecute(object? parameter)
     /// </param>
     public void Execute(object? parameter)
     {
-        _execute(parameter);
+        // For now, we are ignoring the warning about the parameter being null.
+        _execute(parameter!);
     }
 
     /// <summary>
diff --git a/FAFB-PowerShell-Tool/TextBoxViewModel.cs b/ActiveDirectoryQuerier/TextBoxViewModel.cs
similarity index 80%
rename from FAFB-PowerShell-Tool/TextBoxViewModel.cs
rename to ActiveDirectoryQuerier/TextBoxViewModel.cs
index 01b3542..063b48b 100644
--- a/FAFB-PowerShell-Tool/TextBoxViewModel.cs
+++ b/ActiveDirectoryQuerier/TextBoxViewModel.cs
@@ -1,7 +1,6 @@
-using System.Collections.ObjectModel;
-using System.ComponentModel;
+using System.ComponentModel;
 
-namespace FAFB_PowerShell_Tool;
+namespace ActiveDirectoryQuerier;
 
 /// <summary>
 /// ViewModel for a ComboBox that displays possible parameters for a PowerShell command.
@@ -12,20 +11,13 @@ public sealed class TextBoxViewModel : INotifyPropertyChanged
     public event PropertyChangedEventHandler? PropertyChanged;
     private string _selectedParameterValue = string.Empty;
 
-    /// <summary>
-    /// Empty constructor to initialize a new ComboBoxParameterViewModel.
-    /// </summary>
-    public TextBoxViewModel()
-    { }
-
     /// <summary>
     /// Gets or sets the selected parameter value for the unique ComboBox.
     /// </summary>
     public string SelectedParameterValue
     {
         get => _selectedParameterValue;
-        set
-        {
+        set {
             if (_selectedParameterValue != value)
             {
                 _selectedParameterValue = value;
diff --git a/Directory.Build.props b/Directory.Build.props
new file mode 100644
index 0000000..93f8127
--- /dev/null
+++ b/Directory.Build.props
@@ -0,0 +1,13 @@
+<Project>
+
+	<PropertyGroup>
+		<TargetFramework>net8.0-windows</TargetFramework>
+		<LangVersion>latest</LangVersion>
+		<Nullable>enable</Nullable>
+		<ImplicitUsings>enable</ImplicitUsings>
+		<EnableNETAnalyzers>true</EnableNETAnalyzers>
+	</PropertyGroup>
+
+</Project>
+
+
diff --git a/Docs/Figma/README.md b/Docs/Figma/README.md
deleted file mode 100644
index fff779c..0000000
--- a/Docs/Figma/README.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# Figma Demo
-
-This contains pictures/screenshots of the pre-coding design and demo of the application. Its purpose was to create a concept for what the gui might and should look like.
diff --git a/FAFB-PowerShell-Tool/FAFB-PowerShell-Tool.csproj b/FAFB-PowerShell-Tool/FAFB-PowerShell-Tool.csproj
deleted file mode 100644
index d382596..0000000
--- a/FAFB-PowerShell-Tool/FAFB-PowerShell-Tool.csproj
+++ /dev/null
@@ -1,37 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>WinExe</OutputType>
-    <TargetFramework>net6.0-windows</TargetFramework>
-    <PlatformTarget>x64</PlatformTarget>
-    <RootNamespace>FAFB_PowerShell_Tool</RootNamespace>
-    <Nullable>enable</Nullable>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <EnableNETAnalyzers>true</EnableNETAnalyzers>
-    <UseWPF>true</UseWPF>
-
-	<!-- Project Info. -->
-    <Title>Active Directory Querier</Title>
-    <Version>0.4.1</Version>
-	<Authors>Hunter T., Pieter Landry Sobtafo, Joseph</Authors>
-    <RepositoryUrl>https://github.com/StrangeRanger/FAFB-PowerShell-Tool</RepositoryUrl>
-
-	<!-- Project Compile Time Settings. -->
-    <PublishSingleFile>false</PublishSingleFile>
-    <SelfContained>false</SelfContained> <!-- changed from true to false-->
-    <DebugType>embedded</DebugType>
-    <IncludeNativeLibrariesForSelfExtract>true</IncludeNativeLibrariesForSelfExtract>
-  </PropertyGroup>
-
-  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <DebugType>full</DebugType>
-    <DocumentationFile></DocumentationFile>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.Management.Infrastructure" Version="3.0.0" />
-    <PackageReference Include="Microsoft.PowerShell.SDK" Version="7.2.18" />
-    <PackageReference Include="System.Management.Automation" Version="7.2.18" />
-  </ItemGroup>
-
-</Project>
diff --git a/FAFB-PowerShell-Tool/MainWindowViewModel.cs b/FAFB-PowerShell-Tool/MainWindowViewModel.cs
deleted file mode 100644
index 3b1bb2b..0000000
--- a/FAFB-PowerShell-Tool/MainWindowViewModel.cs
+++ /dev/null
@@ -1,718 +0,0 @@
-using System.Collections.ObjectModel;
-using System.ComponentModel;
-using System.Diagnostics;
-using System.Management.Automation.Runspaces;
-using System.Windows.Controls;
-using System.Windows.Input;
-using FAFB_PowerShell_Tool.PowerShell;
-using System.Management.Automation;
-using System.IO;
-using System.Globalization;
-using System.Text;
-using Microsoft.Win32;
-using Microsoft.WSMan.Management;
-using Newtonsoft.Json.Linq;
-
-namespace FAFB_PowerShell_Tool;
-
-/// <summary>
-/// Primary view model for the MainWindow.
-/// </summary>
-public sealed class MainWindowViewModel : INotifyPropertyChanged
-{
-    // ------------------- Fields ------------------- //
-
-    public event PropertyChangedEventHandler? PropertyChanged;
-    private readonly PowerShellExecutor _powerShellExecutor;
-    private Command _selectedCommand;
-    private string _powerShellOutput;
-    private ObservableCollection<Button> _buttons;
-    private CustomQueries.query _currentQuery;
-    private CustomQueries _customQuery = new();
-    private string _queryName;
-    private string _queryDescription;
-    private string _parameterValue;
-
-    // ----------------- Properties ----------------- //
-
-    /// <summary>
-    /// Collection of Active Directory commands available for execution.
-    /// </summary>
-    public ObservableCollection<Command> ActiveDirectoryCommandList { get; private set; }
-
-    /// <summary>
-    /// The name of the query.
-    /// </summary>
-    /// New code begins here
-   
-    private void LoadCustomQueries()
-    {
-        try
-        {
-            // Assuming Get-Users returns a list of users
-            List<User> users = GetUsersCommand(); // Replace this with your actual PowerShell command
-
-            foreach (User user in users)
-            {
-                // Create a new button for each user
-                Button newUserButton = new() { Height = 48 };
-
-                // Set button content (text) to user's name or any relevant information
-                newUserButton.Content = user.UserName;
-
-                // Bind the user object to the button
-                newUserButton.Tag = user;
-
-                // Create a context menu for the button
-                ContextMenu contextMenu = new ContextMenu();
-
-                // Add menu items to the context menu
-                MenuItem menuItem1 = new MenuItem { Header = "Execute" };
-                menuItem1.Command = ExecuteCommandButton;
-                menuItem1.CommandParameter = newUserButton;
-
-                MenuItem menuItem2 = new MenuItem { Header = "Edit" };
-                menuItem2.Command = EditCustomQuery;
-                menuItem2.CommandParameter = newUserButton;
-
-                MenuItem menuItem3 = new MenuItem { Header = "Delete" };
-                menuItem3.Command = Remove_ParameterComboBox;
-
-                // Add menu items to the context menu
-                contextMenu.Items.Add(menuItem1);
-                contextMenu.Items.Add(menuItem2);
-                contextMenu.Items.Add(menuItem3);
-
-                // Set the context menu for the button
-                newUserButton.ContextMenu = contextMenu;
-
-                // Add the button to the stack panel
-                ButtonStackPanel.Add(newUserButton);
-            }
-        }
-        catch (Exception ex)
-        {
-            Trace.WriteLine(ex);
-        }
-    }
-
-    // Replace User with your actual user class
-    public class User
-    {
-        public string UserName { get; set; }
-        // Add other properties as needed
-    }
-
-    // Replace this with your actual PowerShell command to get users
-    private List<User> GetUsersCommand()
-    {
-        // Your PowerShell command logic to get users
-        return new List<User>
-    {
-        new User { UserName = "User1" },
-        new User { UserName = "User2" },
-        
-    };
-    }
-
-    /// New code ends here
-    
-
-
-    public string QueryName
-    {
-        get {
-            return _queryName;
-        }
-        set {
-            if (_queryName != value)
-            {
-                _queryName = value;
-                OnPropertyChanged(nameof(QueryName));
-            }
-        }
-    }
-
-    /// <summary>
-    /// This is the Parameter Value for the param
-    /// </summary>
-    public string ParameterValue
-    {
-        get
-        {
-            return _parameterValue;
-        }
-        set
-        {
-            if (_parameterValue != value)
-            {
-                _parameterValue = value;
-                OnPropertyChanged(nameof(ParameterValue));
-            }
-        }
-    }
-
-    /// <summary>
-    /// The description of the query.
-    /// </summary>
-    public string QueryDescription
-    {
-        get {
-            return _queryDescription;
-        }
-        set {
-            if (_queryDescription != value)
-            {
-                _queryDescription = value;
-                OnPropertyChanged(nameof(QueryDescription));
-            }
-        }
-    }
-
-    /// <summary>
-    /// This property creates a collection of buttons to be added to the stack panel for custom queries
-    /// </summary>
-    public ObservableCollection<Button> ButtonStackPanel
-    {
-        get {
-            if (_buttons == null)
-            {
-                _buttons = new ObservableCollection<Button>();
-            }
-
-            return _buttons;
-        }
-    }
-
-    /// <summary>
-    /// This is a helper command for running PerformSavedQueries
-    /// </summary>
-    public ICommand SavedQueries { get; }
-
-    /// <summary>
-    /// This is the command for the edit option on custom queries
-    /// </summary>
-    public ICommand EditCustomQuery { get; }
-
-    /// <summary>
-    /// Collection of possible parameters for the currently selected command.
-    /// </summary>
-    public ObservableCollection<string>? PossibleParameterList { get; private set; }
-
-    /// <summary>
-    /// Collection of ComboBoxParameterViewModels to dynamically handle multiple parameter selections.
-    /// </summary>
-    public ObservableCollection<ComboBoxParameterViewModel> DynamicParameterCollection { get; }
-
-    /// <summary>
-    /// Collection of ComboBoxParameterViewModels to dynamically handle multiple parameter value selections.
-    /// </summary>
-    public ObservableCollection<TextBoxViewModel> DynamicParameterValuesCollection { get; }
-
-    /// <summary>
-    /// Command to execute the selected PowerShell command.
-    /// </summary>
-    public ICommand ExecuteCommand { get; }
-
-    /// <summary>
-    /// Command to execute the buttons inside Custom Command buttons
-    /// </summary>
-    public ICommand ExecuteCommandButton { get;  }
-
-    /// <summary>
-    /// Command to add a new parameter ComboBox to the UI.
-    /// </summary>
-    public ICommand AddNewParameterComboBox { get; }
-
-    /// <summary>
-    /// Command to add a new parameter ComboBox to the UI.
-    /// TODO: Rename this property to match Property naming conventions!!!
-    /// </summary>
-    public ICommand Remove_ParameterComboBox { get; }
-
-    /// <summary>
-    /// Command to have the output send to a text file when executing
-    /// TODO: Get-only auto-property 'OutputToText' is never assigned!!!
-    /// </summary>
-    public ICommand _OutputToText { get; }
-
-    /// <summary>
-    /// Command to output to a csv when executing
-    /// </summary>
-    public ICommand OutputToCsv { get; }
-
-    /// <summary>
-    /// Gets or sets the currently selected PowerShell command.
-    /// </summary>
-    public Command SelectedCommand
-    {
-        get => _selectedCommand;
-        set {
-            _selectedCommand = value;
-            OnPropertyChanged(nameof(SelectedCommand));
-            LoadParametersAsync(value);
-        }
-    }
-
-    /// <summary>
-    /// Gets or sets the output of the executed PowerShell command.
-    /// </summary>
-    public string PowerShellOutput
-    {
-        get => _powerShellOutput;
-        set {
-            _powerShellOutput = value;
-            OnPropertyChanged(nameof(PowerShellOutput));
-        }
-    }
-
-    // ----------------- Constructor ----------------- //
-
-    /// <summary>
-    /// Class constructor.
-    /// TODO: Fix warnings about possible null values.
-    /// </summary>
-    public MainWindowViewModel()
-    {
-        _powerShellExecutor = new PowerShellExecutor();
-        ExecuteCommand = new RelayCommand(Execute);
-        OutputToCsv = new RelayCommand(_OutputToCsvAsync);
-        _OutputToText = new RelayCommand(OutputPowershellOutputToText);
-        AddNewParameterComboBox = new RelayCommand(AddParameterComboBox);
-        Remove_ParameterComboBox = new RelayCommand(RemoveParameterComboBox);
-        SavedQueries = new RelayCommand(PerformSavedQueries);
-        EditCustomQuery = new RelayCommand(PerformEditCustomQuery);
-        // Change the naming I know 
-        ExecuteCommandButton = new RelayCommand(ExecuteButtonCommand);
-
-        _currentQuery = new CustomQueries.query();
-
-        DynamicParameterCollection = new ObservableCollection<ComboBoxParameterViewModel>();
-        DynamicParameterValuesCollection = new ObservableCollection<TextBoxViewModel>();
-
-        InitializeCommandsAsync();
-        LoadCustomQueries(); // Calls method to deserialize and load buttons.
-
-        // Debug
-        foreach (Button t in ButtonStackPanel)
-        {
-            CustomQueries.query test = (CustomQueries.query)t.Tag;
-            Trace.WriteLine(test.commandName);
-        }
-    }
-
-    // ----------------- Methods ----------------- //
-
-    /// <summary>
-    /// This method will edit the Query and fill out the field with the desired query and you can edit the query
-    /// TODO: Add a description to the parameter of this method.
-    /// </summary>
-    /// <param name="sender"></param>
-    private void PerformEditCustomQuery(object sender)
-    {
-        // Get the button that we are editing
-        Button currButton = (Button)sender;
-        CustomQueries.query currQuery = (CustomQueries.query)currButton.Tag;
-
-        // Need to fill in the queryName
-        QueryName = currQuery.queryName;
-        // Fill in the queryDescription
-        QueryDescription = currQuery.queryDescription;
-        // Fill in the commandName
-        Command chosenCommand = ActiveDirectoryCommandList.FirstOrDefault(item => item.CommandText == currQuery.commandName);
-        SelectedCommand = chosenCommand;
-        OnPropertyChanged(nameof(SelectedCommand));
-
-        Trace.WriteLine(SelectedCommand.CommandText);
-
-        LoadParametersAsync(SelectedCommand);
-
-        Trace.WriteLine(PossibleParameterList.Count());
-
-        // Fill in Parameters and values
-
-        for (int i = 0; i < currQuery.commandParameters.Count(); i++)
-        {
-            //DynamicParameterCollection.Add(new ComboBoxParameterViewModel(PossibleParameterList));
-            //DynamicParameterValuesCollection.Add(new TextBoxViewModel());
-
-            //DynamicParameterCollection[i].SelectedParameter = PossibleParameterList.FirstOrDefault(item => item == currQuery.commandParameters[i]);
-            //DynamicParameterValuesCollection[i].SelectedParameterValue = PossibleParameterList.FirstOrDefault(item => item == currQuery.commandParametersValues[i]);
-
-        }
-        
-        Trace.WriteLine("This is after the setting of the command");
-        Trace.WriteLine(SelectedCommand.CommandText);
-        // Fill in the commandParameters
-    }
-
-    /// <summary>
-    ///  TODO: Change the naming
-    /// </summary>
-    /// <param name="_"></param>
-    public void ExecuteButtonCommand(object _)
-    {
-        var currButton = _ as Button;
-
-        CustomQueries.query ButtonQuery = (CustomQueries.query)currButton.Tag;
-
-        ExecuteGenericCommand(ButtonQuery.command);
-    }
-
-    /// <summary>
-    /// This method will load the custom queries from the file.
-    /// </summary>
-    private void LoadCustomQueries()
-    {
-        try
-        {
-            _customQuery.LoadData();
-
-            // parameter counter
-            int i = 0;
-            foreach (CustomQueries.query cQuery in _customQuery.Queries)
-            {
-                // Creates a new button for each query
-                Button newButton = new() { Height = 48 };
-
-                // Names the query the command if null otherwise names it correctly
-                if (cQuery.queryName != null)
-                {
-                    newButton.Content = cQuery.queryName;
-                }
-                else
-                {
-                    newButton.Content = cQuery.commandName;
-                }
-
-                // Binds the query to the button
-                newButton.Tag = cQuery;
-
-                // Want to add right click context menu to each button
-                ContextMenu contextMenu = new ContextMenu();
-
-                MenuItem menuItem1 = new MenuItem { Header = "Execute" };
-                menuItem1.Command = ExecuteCommandButton;
-                menuItem1.CommandParameter = newButton;
-
-                MenuItem menuItem2 = new MenuItem { Header = "Edit" };
-                menuItem2.Command = EditCustomQuery;
-                menuItem2.CommandParameter = newButton; // This set the parent of the menuitem to the button so it is accessible
-
-                MenuItem menuItem3 = new MenuItem { Header = "Delete" };
-                menuItem3.Command = Remove_ParameterComboBox;
-
-                // Add menu item to the context menu
-                contextMenu.Items.Add(menuItem1);
-                contextMenu.Items.Add(menuItem2);
-                contextMenu.Items.Add(menuItem3);
-
-                // Add the context menu to the button
-                newButton.ContextMenu = contextMenu;
-
-                // Lastly add the button to the stack panel
-                ButtonStackPanel.Add(newButton);
-            }
-        }
-        catch (Exception ex)
-        {
-            Trace.WriteLine(ex);
-        }
-    }
-
-    /// <summary>
-    /// Executes the selected PowerShell command asynchronously.
-    /// </summary>
-    /// <param name="_">Parameter is not used, but required for the ICommand interface.</param>
-    private async void Execute(object _)
-    {
-        await ExecuteSelectedCommand();
-    }
-
-    /// <summary>
-    /// Initializes the list of Active Directory commands asynchronously.
-    /// </summary>
-    private async void InitializeCommandsAsync()
-    {
-        ObservableCollection<Command> list = await ActiveDirectoryCommands.GetActiveDirectoryCommands();
-        ActiveDirectoryCommandList = new(list);
-        OnPropertyChanged(nameof(ActiveDirectoryCommandList));
-    }
-
-    /// <summary>
-    /// Loads the parameters for the selected PowerShell command asynchronously.
-    /// </summary>
-    /// <param name="selectedCommand">The PowerShell command whose parameters are to be loaded.</param>
-    private async void LoadParametersAsync(Command selectedCommand)
-    {
-        CommandParameters commandParameters = new CommandParameters();
-        await commandParameters.LoadCommandParametersAsync(selectedCommand);
-        PossibleParameterList = new ObservableCollection<string>(commandParameters.PossibleParameters);
-        OnPropertyChanged(nameof(PossibleParameterList));
-
-        // Update the possible properties of the ComboBoxParameterViewModels.
-        foreach (ComboBoxParameterViewModel comboBoxParameterViewModel in DynamicParameterCollection)
-        {
-            comboBoxParameterViewModel.PossibleParameterList = PossibleParameterList;
-        }
-    }
-
-    /// <summary>
-    /// Executes the currently selected PowerShell command and updates the PowerShellOutput property with the result.
-    /// </summary>
-    /// <returns>A Task representing the asynchronous operation of executing the command.</returns>
-    private async Task ExecuteSelectedCommand()
-    {
-        try
-        {
-            SelectedCommand.Parameters.Clear();
-
-            // Add selected parameters and their values to the command.
-            for (int i = 0; i < DynamicParameterCollection.Count; i++)
-            {
-                string parameterName = DynamicParameterCollection[i].SelectedParameter;
-                string parameterValue = DynamicParameterValuesCollection[i].SelectedParameterValue;
-                SelectedCommand.Parameters.Add(new CommandParameter(parameterName, parameterValue));
-            }
-
-            ReturnValues result = await _powerShellExecutor.ExecuteAsync(SelectedCommand);
-
-            if (result.HadErrors)
-            {
-                PowerShellOutput = string.Join(Environment.NewLine, result.StdErr);
-                return;
-            }
-
-            PowerShellOutput = string.Join(Environment.NewLine, result.StdOut);
-        }
-        catch (Exception ex)
-        {
-            PowerShellOutput = $"Error executing command: {ex.Message}";
-        }
-    }
-
-    /// <summary>
-    /// Executes the currently selected PowerShell command and updates the PowerShellOutput property with the result.
-    /// </summary>
-    /// <returns>A Task representing the asynchronous operation of executing the command.</returns>
-    private async Task ExecuteGenericCommand(Command toBeExecuted)
-    {
-        try
-        {
-            //Execute the command
-            ReturnValues result = await _powerShellExecutor.ExecuteAsync(toBeExecuted);
-            //Error handling
-            if (result.HadErrors)
-            {
-                PowerShellOutput = string.Join(Environment.NewLine, result.StdErr);
-                return;
-            }
-
-            PowerShellOutput = string.Join(Environment.NewLine, result.StdOut);
-        }
-        catch (Exception ex)
-        {
-            PowerShellOutput = $"Error executing command: {ex.Message}";
-        }
-    }
-
-    /// <summary>
-    /// Adds a new parameter and value selection ComboBox to the DynamicParameterCollection.
-    /// </summary>
-    /// <param name="_">Neccisary Parameter that passes the object that is clicked</param>
-    private void AddParameterComboBox(object _)
-    {
-        // Check if some variable is null and throw an exception if it is
-        if (PossibleParameterList is null)
-        {
-            Trace.WriteLine("PossibleParameterList has not been populated yet.");
-            return;
-        }
-        
-        DynamicParameterCollection.Add(new ComboBoxParameterViewModel(PossibleParameterList));
-        DynamicParameterValuesCollection.Add(new TextBoxViewModel());
-    }
-
-    /// <summary>
-    /// This will be to Execute a query to a text file
-    /// TODO: Add a description to the parameter of this method.
-    /// TODO: Rename this method to match method naming conventions!!!
-    /// </summary>
-    /// <param name="_"></param>
-    private async void OutputPowershellOutputToText(object _)
-    {
-        await ExecuteSelectedCommand();
-
-        //Filepath
-        // Write the text to a file & prompt user for the location
-
-        SaveFileDialog saveFileDialog = new SaveFileDialog();
-
-        // Set properties of the OpenFileDialog
-        saveFileDialog.FileName = "Document"; // Default file name
-        saveFileDialog.Filter = "All files(*.*) | *.*";
-
-        // Display
-        Nullable<bool> result = saveFileDialog.ShowDialog();
-
-        // Get file and write text
-        if (result == true)
-        {
-            // Open document
-            string filePath = saveFileDialog.FileName;
-            File.WriteAllText(filePath, PowerShellOutput);
-        }
-    }
-
-    /// <summary>
-    /// TODO: Rename this method to match method naming conventions!!!
-    /// This method is in the working
-    /// Status: prompts user for file path and saves correctly though the string could be edited to be better
-    /// </summary>
-    /// <param name="_">Represents the object that the command is bound to</param>
-    private async void _OutputToCsvAsync(object _)
-    { 
-        await ExecuteSelectedCommand();
-
-        
-        var csv = new StringBuilder();
-        string[] output = PowerShellOutput.Split(' ', '\n');
-
-        for (int i = 0; i < output.Length - 2; i++)
-        {
-            
-            var first = output[i];
-            var second = output[i + 1];
-            //format the strings and add them to a string
-            var newLine = string.Format("{0},{1}", first, second);
-            csv.AppendLine(newLine);
-        }
-
-        // Write the text to a file & prompt user for the location
-
-        SaveFileDialog saveFileDialog = new SaveFileDialog();
-
-        // Set properties of the OpenFileDialog
-        saveFileDialog.FileName = "Document"; // Default file name
-        saveFileDialog.Filter = "All files(*.*) | *.*";
-
-        // Display
-        Nullable<bool> result = saveFileDialog.ShowDialog();
-
-        // Get file and write text
-        if (result == true)
-        {
-            // Open document
-            string filePath = saveFileDialog.FileName;
-            File.WriteAllText(filePath, csv.ToString());
-        }
-
-        //debug
-        //Trace.WriteLine(PowerShellOutput);
-    }
-
-    /// <summary>
-    /// This method is for getting the currently selected command at anytime !Still in the works!
-    /// </summary>
-    public void UpdateSelectedCommand()
-    {
-        // Try to get the content within the drop downs
-        try
-        {
-            int i = 0;
-            foreach (var comboBoxData in DynamicParameterCollection)
-            {
-                string selectedItem = comboBoxData.SelectedParameter;
-                // Need to look at this to see if it is working with the object type and then serialize it
-                SelectedCommand.Parameters.Add(new CommandParameter(comboBoxData.SelectedParameter, DynamicParameterValuesCollection[i].SelectedParameterValue));
-            }
-        }
-        catch (Exception ex)
-        {
-            Console.Write(ex);
-        }
-    }
-
-    /// <summary>
-    /// Gets the CustomQuery.query object for the current query when called TODO: It needs to be tested !Still in the
-    /// works !
-    /// </summary>
-    public void GetCurrentQuery()
-    {
-        // Update the selected command
-        UpdateSelectedCommand();
-
-        try
-        {
-            _currentQuery.queryDescription = QueryDescription;
-            _currentQuery.queryName = QueryName;
-
-            _currentQuery.commandName = SelectedCommand.CommandText;
-
-            int i = 0;
-            foreach (CommandParameter CP in SelectedCommand.Parameters)
-            {
-                _currentQuery.commandParameters[i] = (CP.Name);
-                // CurrentQuery.commandParametersValues[i] = ((string) CP.Value);   The values are not quite working yet
-                i++;
-            }
-        }
-        catch (Exception ex)
-        {
-            Trace.WriteLine(ex);
-        }
-    }
-
-    /// <summary>
-    /// Removes the parameter box after adding them
-    /// TODO: Add a description to the parameter of this method.
-    /// </summary>
-    /// <param name="_"></param>
-    private void RemoveParameterComboBox(object _)
-    {
-        if (DynamicParameterCollection.Count != 0)
-        {
-            DynamicParameterCollection.RemoveAt(DynamicParameterCollection.Count - 1);
-        }
-    }
-
-    /// <summary>
-    /// This method will serialize the command and add it to the list of buttons.
-    /// </summary>
-    /// <param name="commandParameter">This is not used but neccisary for the relaycommand</param>
-    private void PerformSavedQueries(object commandParameter)
-    {
-        // Try to get the content within the drop downs
-        try
-        {
-            int i = 0;
-            foreach (var comboBoxData in DynamicParameterCollection)
-            {
-                string selectedItem = comboBoxData.SelectedParameter;
-                // Need to look at this to see if it is working with the object type and then serialize it
-                //Trace.WriteLine(DynamicParameterValuesCollection[i].SelectedParameterValue);
-
-                SelectedCommand.Parameters.Add(new CommandParameter(comboBoxData.SelectedParameter, DynamicParameterValuesCollection[i].SelectedParameterValue));
-                i++;
-            }
-
-            _customQuery.SerializeCommand(SelectedCommand, QueryName, QueryDescription);
-
-            Button newButton = new() { Content = SelectedCommand.CommandText, Height = 48 };
-            ButtonStackPanel.Add(newButton);
-        }
-        catch (Exception ex)
-        {
-            Console.Write(ex);
-        }
-    }
-
-    /// <summary>
-    /// Handles property change notifications.
-    /// </summary>
-    /// <param name="propertyName">Name of the property that changed.</param>
-    private void OnPropertyChanged(string propertyName)
-    {
-        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
-    }
-}
diff --git a/FAFB-PowerShell-Tool/MessageBoxOutput.cs b/FAFB-PowerShell-Tool/MessageBoxOutput.cs
deleted file mode 100644
index d5fb396..0000000
--- a/FAFB-PowerShell-Tool/MessageBoxOutput.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-using System.Windows;
-
-namespace FAFB_PowerShell_Tool;
-
-/// <summary>
-/// Provides a utility class for displaying MessageBoxes with different types of outputs.
-/// </summary>
-public static class MessageBoxOutput
-{
-    /// <summary>
-    /// Defines the type of output to display in the MessageBox.
-    /// </summary>
-    public enum OutputType
-    {
-        Error,
-        Generic
-    }
-
-    /// <summary>
-    /// Shows a MessageBox with a specified message and output type.
-    /// </summary>
-    /// <param name="message">The message to be displayed in the MessageBox.</param>
-    /// <param name="type">The type of MessageBox to display, defaulted to Generic.</param>
-    public static void Show(string message, OutputType type = OutputType.Generic)
-    {
-        switch (type)
-        {
-        case OutputType.Error:
-            MessageBox.Show(message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
-            break;
-        case OutputType.Generic:
-            MessageBox.Show(message, "Command Output", MessageBoxButton.OK, MessageBoxImage.None);
-            break;
-        default:
-            throw new ArgumentOutOfRangeException(nameof(type), type, null);
-        }
-    }
-}
diff --git a/FAFB-PowerShell-Tool/PSSaveOptions.cs b/FAFB-PowerShell-Tool/PSSaveOptions.cs
deleted file mode 100644
index 78b8b2f..0000000
--- a/FAFB-PowerShell-Tool/PSSaveOptions.cs
+++ /dev/null
@@ -1,54 +0,0 @@
-using FAFB_PowerShell_Tool.PowerShell;
-using System.Management.Automation.Internal;
-
-namespace FAFB_PowerShell_Tool;
-
-/// <summary>
-/// This class *might* be used for housing the save options
-/// </summary>
-public class PSSaveOptions
-{
-    /// <summary>
-    /// This would be to output the query to a csv, will need to eventually adapt to a guicommand as well most likely
-    /// </summary>
-    /// <param name="commandString"> This is the internal command that we want to output to a csv </param>
-    /*public Command OutputToCSV(Command commandString)
-    {
-        //Checks to see if the parameters are null,
-        if (commandString.Parameters == null || commandString.Parameters.Count == 0)
-        {
-            //if they are null then make a new array with the output option, currently to relative path to SavedOutput
-    folder commandString.Parameters.Add("| Export-CSV ..\\..\\..\\SavedOutput\\output.csv");
-        }
-        else
-        {
-            // If it is not null we will clone the parameters and add the output parameter to the new string and then
-    set the array string[] temp = commandString.Parameters; Array.Resize(ref temp, temp.Length + 1); temp[temp.Length -
-    1] = "| Export-CSV ..\\..\\..\\SavedOutput\\output.csv";
-            //setting
-            commandString.Parameters = temp;
-        }
-        //return the commandString with the updated parameters
-        return commandString;
-    }*/
-
-    /// <summary>
-    /// This would be to have the query output to a message box
-    /// </summary>
-    public InternalCommand OutputToMessageBox(InternalCommand commandSting)
-    {
-        return null;
-    }
-
-    /// <summary>
-    /// This will be to save the query to a text file
-    /// </summary>
-    public void SaveToTxt(ReturnValues results)
-    { }
-
-    /// <summary>
-    /// This is used for saving the file to a PS1 powershell file
-    /// </summary>
-    public void SaveToPS(ReturnValues results)
-    { }
-}
diff --git a/FAFB-PowerShell-Tool/PowerShell/CommandParameters.cs b/FAFB-PowerShell-Tool/PowerShell/CommandParameters.cs
deleted file mode 100644
index 6efc036..0000000
--- a/FAFB-PowerShell-Tool/PowerShell/CommandParameters.cs
+++ /dev/null
@@ -1,69 +0,0 @@
-using System.Collections.ObjectModel;
-using System.Diagnostics;
-using System.Management.Automation;
-using System.Management.Automation.Runspaces;
-
-namespace FAFB_PowerShell_Tool.PowerShell;
-
-/// <summary>
-/// Manages and provides the parameters available for a given PowerShell command.
-/// </summary>
-public class CommandParameters
-{
-    private readonly ObservableCollection<string> _possibleParameters = new();
-
-    /// <summary>
-    /// Gets the collection of possible parameters for a command.
-    /// </summary>
-    /// <note>
-    /// I realize that this isn't a very clean way of doing things, but it's the best I could come up with at the time.
-    /// </note>
-    /// <exception cref="InvalidOperationException">Thrown when the collection has not been populated yet.</exception>
-    public ObservableCollection<string> PossibleParameters
-    {
-        get {
-            if (_possibleParameters.Count == 0)
-            {
-                throw new InvalidOperationException(
-                    "PossibleParameters has not been populated via 'LoadCommandParametersAsync'.");
-            }
-
-            return _possibleParameters;
-        }
-    }
-
-    /// <summary>
-    /// Asynchronously loads the possible parameters for the specified command into the '_possibleParameters'
-    /// collection.
-    /// </summary>
-    /// <param name="commandObject">The PowerShell command object whose parameters are to be loaded.</param>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    public async Task LoadCommandParametersAsync(Command? commandObject)
-    {
-        // Check if commandObject is null
-        if (commandObject is null)
-        {
-            Trace.WriteLine("Error: commandObject is null");
-            _possibleParameters.Add("No valid command provided");
-            return;
-        }
-
-        if (_possibleParameters.Count == 0)
-        {
-            using (var ps = System.Management.Automation.PowerShell.Create())
-            {
-                // The command exists, get its parameters
-                string commandString = $"Get-Command {commandObject.CommandText} | Select -ExpandProperty Parameters | ForEach-Object {{ $_.Keys }}";
-
-                ps.Commands.Clear();
-                ps.AddScript(commandString);
-                PSDataCollection<PSObject> result = await ps.InvokeAsync();
-                
-                foreach (PSObject cmd in result)
-                {
-                    _possibleParameters.Add($"-{cmd}");
-                }
-            }
-        }
-    }
-}
diff --git a/FAFB-PowerShell-Tool/PowerShell/CustomQueries.cs b/FAFB-PowerShell-Tool/PowerShell/CustomQueries.cs
deleted file mode 100644
index bc432bd..0000000
--- a/FAFB-PowerShell-Tool/PowerShell/CustomQueries.cs
+++ /dev/null
@@ -1,187 +0,0 @@
-using System.Diagnostics;
-using System.IO;
-using System.Management.Automation.Runspaces;
-using System.Text.Json;
-using System.Text.Json.Serialization;
-
-namespace FAFB_PowerShell_Tool.PowerShell
-{
-    /// <summary>
-    /// This class is used to save a json file named "CustomQueries.dat" inside of
-    /// \FAFB-PowerShell-Tool\FAFB-PowerShell-Tool\bin\Debug\net6.0-windows This
-    /// </summary>
-    /// <param name="Queries"></param>
-    internal class CustomQueries
-    {
-        public class query
-        {
-            /// <summary>
-            /// Command that should help with Binding the command to the query for the buttons sake
-            /// </summary>
-            [JsonIgnore]
-            public Command command { get; set; }
-
-            /// <summary>
-            /// Used for serializing the Command Name
-            /// </summary>
-            public string commandName { get; set; }
-
-            /// <summary>
-            /// Used for Serializing the Commands parameters
-            /// </summary>
-            public string[] commandParameters { get; set; }
-
-            /// <summary>
-            /// Used for Serializing the Commands parameters
-            /// </summary>
-            public string[] commandParametersValues { get; set; }
-
-            /// <summary>
-            /// Used for the name of the custom Query
-            /// </summary>
-            public string queryName { get; set; }
-
-            /// <summary>
-            /// Used for the Custom Queries Description
-            /// </summary>
-            public string queryDescription { get; set; }
-
-            /// <summary>
-            /// Contructor for the query class
-            /// </summary>
-            /// <param name="cN"></param>
-            /// <param name="commandParams"></param>
-            public query(string cN, string[] commandParams)
-            {
-                this.commandName = cN;
-                this.commandParameters = commandParams;
-            }
-
-            /// <summary>
-            /// Contructor for the query class
-            /// </summary>
-            /// <param name="cN"></param>
-            public query(string cN)
-            {
-                this.commandName = cN;
-            }
-
-            /// <summary>
-            /// Empty Contructor for the query class
-            /// </summary>
-            public query()
-            { }
-        }
-
-        public List<query> Queries = new List<query>();
-
-        /// <summary>
-        /// This a variable for feeding options to the Json serializer
-        /// </summary>
-        private static readonly JsonSerializerOptions _options = new() {
-            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
-            WriteIndented = true,
-            ReferenceHandler = ReferenceHandler.Preserve,
-        };
-        /// <summary>
-        /// Emtpy Contructor
-        /// </summary>
-        public CustomQueries()
-        { }
-        /// <summary>
-        /// This takes the Queries List and serializes it to a file
-        /// </summary>
-        public void SerializeMethod()
-        {
-            try
-            {
-                string json = JsonSerializer.Serialize(Queries, _options);
-                File.WriteAllText("CustomQueries.dat", json);
-            }
-            catch (Exception ex)
-            {
-                Trace.WriteLine(ex);
-            }
-        }
-        /// <summary>
-        /// This method is for serializing a command type, so it converts the type to a query and then serializes it
-        /// </summary>
-        public void SerializeCommand(Command cmnd, string queryName, string queryDescription)
-        {
-            Trace.WriteLine(cmnd.Parameters.Count);
-
-            string[] commandParameters = new string[cmnd.Parameters.Count];
-            string[] commandParameterValues = new string[cmnd.Parameters.Count];
-            query newQuery = new query(cmnd.CommandText);
-
-            // Set name and description
-            newQuery.queryName = queryName;
-            newQuery.queryDescription = queryDescription;
-
-            // Iterate over the parameters and add them to the string
-
-            for (int i = 0; i < cmnd.Parameters.Count; i++)
-            {
-                CommandParameter param = cmnd.Parameters[i];
-
-                Trace.WriteLine(param.Name + " Value: ");
-
-                commandParameters[i] = param.Name;
-                commandParameterValues[i] = param.Value.ToString(); 
-            }
-            newQuery.commandParameters = commandParameters;
-            newQuery.commandParametersValues = commandParameterValues;
-
-            Queries.Add(newQuery);
-
-            CustomQueries customQueries = new CustomQueries();
-            customQueries.SerializeMethod();
-            try
-            {
-                string json = JsonSerializer.Serialize(Queries, _options);
-                Trace.WriteLine(json);
-                File.WriteAllText("CustomQueries.dat", json);
-            }
-            catch (Exception ex)
-            {
-                Trace.WriteLine(ex);
-            }
-        }
-        /// <summary>
-        /// This method Loads the string from the saved file "CustomQueries.dat" then gives it to the Queries List
-        /// </summary>
-        public void LoadData()
-        {
-            try
-            {
-                // Opens file and reads it then adds the json to the Queries List
-                string json = File.ReadAllText("CustomQueries.dat");
-                Queries = JsonSerializer.Deserialize<List<query>>(json, _options);
-
-                // Now we want to fill the command variable for each query
-                foreach (query q in Queries)
-                {
-                    Command command = new Command(q.commandName);
-
-                    // Check if there are parameters, and if there are add them to the list
-                    if (q.commandParameters != null)
-                    {
-                        for (int i = 0; i < q.commandParameters.Length; i++)
-                        {
-                            // command.Parameters.Add(q.commandParameters[i], q.commandParametersValues[i]);  -- Once
-                            // the values are working then we will use this
-                            command.Parameters.Add(q.commandParameters[i]);
-                        }
-                    }
-
-                    // set the query command to the command
-                    q.command = command;
-                }
-            }
-            catch (Exception ex)
-            {
-                Trace.WriteLine(ex);
-            }
-        }
-    }
-}
diff --git a/FAFB-PowerShell-Tool/PowerShell/psoutput.txt b/FAFB-PowerShell-Tool/PowerShell/psoutput.txt
deleted file mode 100644
index 7445668..0000000
--- a/FAFB-PowerShell-Tool/PowerShell/psoutput.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-An error occurred while executing the PowerShell command:
-Unable to find a default server with Active Directory Web Services running.
-   at System.Management.Automation.Runspaces.AsyncResult.EndInvoke()
-   at System.Management.Automation.PowerShell.EndInvoke(IAsyncResult asyncResult)
-   at System.Threading.Tasks.TaskFactory`1.FromAsyncCoreLogic(IAsyncResult iar, Func`2 endFunction, Action`1 endAction, Task`1 promise, Boolean requiresSynchronization)
---- End of stack trace from previous location ---
-   at FAFB_PowerShell_Tool.PowerShell.PowerShellExecutor.ExecuteAsync(Command command) in C:\Users\pickl\Source\Repos\FAFB-PowerShell-Tool\FAFB-PowerShell-Tool\PowerShell\PowerShellExecutor.cs:line 77
diff --git a/FAFB-PowerShell-Tool/PowerShell/test.csv b/FAFB-PowerShell-Tool/PowerShell/test.csv
deleted file mode 100644
index b02081b..0000000
--- a/FAFB-PowerShell-Tool/PowerShell/test.csv
+++ /dev/null
@@ -1,62 +0,0 @@
-An,error
-error,occurred
-occurred,while
-while,executing
-executing,the
-the,PowerShell
-PowerShell,command:

-command:
,Unable
-Unable,to
-to,find
-find,a
-a,default
-default,server
-server,with
-with,Active
-Active,Directory
-Directory,Web
-Web,Services
-Services,running.

-running.
,
-,
-,
-,at
-at,System.Management.Automation.Runspaces.AsyncResult.EndInvoke()

-System.Management.Automation.Runspaces.AsyncResult.EndInvoke()
,
-,
-,
-,at
-at,System.Management.Automation.PowerShell.EndInvoke(IAsyncResult
-System.Management.Automation.PowerShell.EndInvoke(IAsyncResult,asyncResult)

-asyncResult)
,
-,
-,
-,at
-at,System.Threading.Tasks.TaskFactory`1.FromAsyncCoreLogic(IAsyncResult
-System.Threading.Tasks.TaskFactory`1.FromAsyncCoreLogic(IAsyncResult,iar,
-iar,,Func`2
-Func`2,endFunction,
-endFunction,,Action`1
-Action`1,endAction,
-endAction,,Task`1
-Task`1,promise,
-promise,,Boolean
-Boolean,requiresSynchronization)

-requiresSynchronization)
,---
----,End
-End,of
-of,stack
-stack,trace
-trace,from
-from,previous
-previous,location
-location,---

----
,
-,
-,
-,at
-at,FAFB_PowerShell_Tool.PowerShell.PowerShellExecutor.ExecuteAsync(Command
-FAFB_PowerShell_Tool.PowerShell.PowerShellExecutor.ExecuteAsync(Command,command)
-command),in
-in,C:\Users\pickl\Source\Repos\FAFB-PowerShell-Tool\FAFB-PowerShell-Tool\PowerShell\PowerShellExecutor.cs:line
-C:\Users\pickl\Source\Repos\FAFB-PowerShell-Tool\FAFB-PowerShell-Tool\PowerShell\PowerShellExecutor.cs:line,77

diff --git a/README.md b/README.md
index d04ede1..45001ef 100644
--- a/README.md
+++ b/README.md
@@ -1,17 +1,17 @@
-# FAFB-PowerShell-Tool
+# Active Directory Querier
 
 [![Project Tracker](https://img.shields.io/badge/repo%20status-Project%20Tracker-lightgrey)](https://wiki.hthompson.dev/en/project-tracker)
 ![Platform](https://img.shields.io/badge/platform-Windows-lightgrey)
 [![Style Guide](https://img.shields.io/badge/code%20style-Style%20Guide-blueviolet)](https://gist.github.com/StrangeRanger/f7f87dd884760f3127adda98d3d4ab14)
 [![Codacy Badge](https://app.codacy.com/project/badge/Grade/ce2ddca07a934a5f85e8061e295f3324)](https://app.codacy.com/gh/StrangeRanger/FAFB-PowerShell-Tool/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
 
-FAFB PowerShell Tool is a Windows GUI for creating, saving, and executing one or more PowerShell commands, against a Local Active Directory.
+Active Directory Querier is a Windows GUI for creating, saving, and executing one or more PowerShell commands, against a Local Active Directory.
 
 ## Getting Started
 
 ### Installing
 
-FAFB PowerShell Tool does not require to be installed. Simply go to [the lastest releases tab](https://github.com/StrangeRanger/FAFB-PowerShell-Tool/releases), and download the version for your appropriate architecture...
+Active Directory Querier does not require to be installed. Simply go to [the lastest releases tab](https://github.com/StrangeRanger/FAFB-PowerShell-Tool/releases), and download the version for your appropriate architecture...
 
 ## Usage