diff --git a/FAFB-PowerShell-Tool.Tests/CustomQueriesTest.cs b/FAFB-PowerShell-Tool.Tests/CustomQueriesTest.cs
index b66f7a6..e6dcd5c 100644
--- a/FAFB-PowerShell-Tool.Tests/CustomQueriesTest.cs
+++ b/FAFB-PowerShell-Tool.Tests/CustomQueriesTest.cs
@@ -1,6 +1,4 @@
 namespace FAFB_PowerShell_Tool.Tests;
 
 public class CustomQueriesTest
-{
-    
-}
\ No newline at end of file
+{ }
diff --git a/FAFB-PowerShell-Tool.Tests/GlobalUsings.cs b/FAFB-PowerShell-Tool.Tests/GlobalUsings.cs
index 8c927eb..c802f44 100644
--- a/FAFB-PowerShell-Tool.Tests/GlobalUsings.cs
+++ b/FAFB-PowerShell-Tool.Tests/GlobalUsings.cs
@@ -1 +1 @@
-global using Xunit;
\ No newline at end of file
+global using Xunit;
diff --git a/FAFB-PowerShell-Tool.Tests/GuiCommandTest.cs b/FAFB-PowerShell-Tool.Tests/GuiCommandTest.cs
deleted file mode 100644
index cd0a5c2..0000000
--- a/FAFB-PowerShell-Tool.Tests/GuiCommandTest.cs
+++ /dev/null
@@ -1,49 +0,0 @@
-using FAFB_PowerShell_Tool.PowerShell.Commands;
-
-namespace FAFB_PowerShell_Tool.Tests;
-
-public class GuiCommandTest
-{
-    [Fact]
-    public void CommandNameIsCorrect()
-    {
-        GuiCommand command = new("Get-ADUser");
-        Assert.Equal("Get-ADUser",  command.CommandName);
-    }
-    
-    [Fact]
-    public void CommandStringGetIsCorrectWhenParametersAreSet()
-    {
-        GuiCommand command = new("Get-ADUser", new[] {"-Identity", "Test"});
-        Assert.Equal("Get-ADUser -Identity Test", command.CommandString);
-        Assert.Equal("-Identity", command.Parameters![0]);
-        Assert.Equal("Test", command.Parameters![1]);
-    }
-
-    [Fact]
-    public void PossibleParametersThrowsInvalidOperationExceptionWhenEmpty()
-    {
-        GuiCommand command = new("Get-ADUser");
-        Assert.Throws<InvalidOperationException>(() => command.PossibleParameters);
-    }
-    
-    [Fact]
-    public async Task PossibleParametersReturnsCorrectly()
-    {
-        GuiCommand command = new("Get-ADUser");
-        await command.LoadCommandParametersAsync();
-        Assert.Contains("-Identity", command.PossibleParameters);
-        Assert.True(command.PossibleParameters.Count > 0);
-    }
-    
-    [Fact]
-    public async Task PossibleParametersReturnsCorrectlyWhenCalledTwice()
-    {
-        GuiCommand command = new("Get-ADUser");
-        await command.LoadCommandParametersAsync();
-        await command.LoadCommandParametersAsync();
-        Assert.Contains("-Identity", command.PossibleParameters);
-        Assert.True(command.PossibleParameters.Count > 0);
-        Assert.Equal(command.PossibleParameters.Count, command.PossibleParameters.Distinct().Count());
-    }
-}
diff --git a/FAFB-PowerShell-Tool.Tests/InternalCommandTest.cs b/FAFB-PowerShell-Tool.Tests/InternalCommandTest.cs
deleted file mode 100644
index 9dcd584..0000000
--- a/FAFB-PowerShell-Tool.Tests/InternalCommandTest.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-using FAFB_PowerShell_Tool.PowerShell.Commands;
-
-namespace FAFB_PowerShell_Tool.Tests;
-
-public class InternalCommandTest
-{
-    [Fact]
-    public void CommandNameIsCorrect()
-    {
-        InternalCommand command = new("Get-ADUser");
-        Assert.Equal("Get-ADUser",  command.CommandName);
-    }
-    
-    [Fact]
-    public void CommandStringGetIsCorrectWhenParametersAreSet()
-    {
-        InternalCommand command = new("Get-ADUser", new[] {"-Identity", "Test"});
-        Assert.Equal("Get-ADUser -Identity Test", command.CommandString);
-    }
-}
\ No newline at end of file
diff --git a/FAFB-PowerShell-Tool.Tests/PowerShellExecutorTest.cs b/FAFB-PowerShell-Tool.Tests/PowerShellExecutorTest.cs
index 24d0b69..4fed025 100644
--- a/FAFB-PowerShell-Tool.Tests/PowerShellExecutorTest.cs
+++ b/FAFB-PowerShell-Tool.Tests/PowerShellExecutorTest.cs
@@ -1,5 +1,5 @@
-using FAFB_PowerShell_Tool.PowerShell;
-using FAFB_PowerShell_Tool.PowerShell.Commands;
+using System.Management.Automation.Runspaces;
+using FAFB_PowerShell_Tool.PowerShell;
 using ArgumentException = System.ArgumentException;
 
 namespace FAFB_PowerShell_Tool.Tests;
@@ -10,30 +10,29 @@ public class PowerShellExecutorTest
     public void ExecuteCommandReturnsAreCorrect()
     {
         PowerShellExecutor powerShell = new();
-        ReturnValues values = powerShell.Execute(new InternalCommand("Get-Process"));
+        ReturnValues values = powerShell.Execute(new Command("Get-Process"));
         Assert.False(values.HadErrors);
         Assert.NotEmpty(values.StdOut);
         Assert.Empty(values.StdErr);
     }
-    
+
     [Fact]
     public void ExecuteBadCommandReturnsAreCorrect()
     {
         PowerShellExecutor powerShell = new();
-        ReturnValues values = powerShell.Execute(new InternalCommand("BadCommand"));
+        ReturnValues values = powerShell.Execute(new Command("BadCommand"));
         Assert.True(values.HadErrors);
         Assert.Empty(values.StdOut);
         Assert.NotEmpty(values.StdErr);
     }
-    
+
     [Fact]
     public void ExecuteBadInternalCommandThrowsInvalidOperationException()
     {
         PowerShellExecutor powerShell = new();
-        Assert.Throws<ArgumentException>(() => powerShell.Execute(new InternalCommand("")));
-        Assert.Throws<ArgumentException>(() => powerShell.Execute(new InternalCommand(" ")));
-        Assert.Throws<ArgumentException>(() => powerShell.Execute(new InternalCommand(null!)));
-        Assert.Throws<ArgumentException>(() => powerShell.Execute(new InternalCommand(string.Empty)));
+        Assert.Throws<ArgumentException>(() => powerShell.Execute(new Command("")));
+        Assert.Throws<ArgumentException>(() => powerShell.Execute(new Command(" ")));
+        Assert.Throws<ArgumentException>(() => powerShell.Execute(new Command(null!)));
+        Assert.Throws<ArgumentException>(() => powerShell.Execute(new Command(string.Empty)));
     }
-
 }
diff --git a/FAFB-PowerShell-Tool.Tests/SaveOptionsTest.cs b/FAFB-PowerShell-Tool.Tests/SaveOptionsTest.cs
index 4f6729a..3b75e06 100644
--- a/FAFB-PowerShell-Tool.Tests/SaveOptionsTest.cs
+++ b/FAFB-PowerShell-Tool.Tests/SaveOptionsTest.cs
@@ -1,4 +1,5 @@
-using FAFB_PowerShell_Tool.PowerShell.Commands;
+using System.Management.Automation.Internal;
+using System.Management.Automation.Runspaces;
 using FAFB_PowerShell_Tool;
 using FAFB_PowerShell_Tool.PowerShell;
 
@@ -6,18 +7,21 @@ namespace FAFB_PowerShell_Tool.Tests;
 
 public class SaveOptionsTest
 {
-    [Fact]
+    /*[Fact]
     public void SaveToCSVAppendsParameter()
     {
         var saveOptions = new PSSaveOptions();
-        InternalCommand command = new("Get-ADUser", new[] { "-Identity", "Test" });
+        Command commandString = new("Get-ADUser");
+        commandString.Parameters.Add("Identity", "Test");
 
-        InternalCommand returnedCommand = saveOptions.OutputToCSV(command);
+        InternalCommand returnedCommand = saveOptions.OutputToCSV(commandString);
 
 
-        Assert.Equal("Get-ADUser -Identity Test | Export-CSV ..\\..\\..\\SavedOutput\\output.csv", returnedCommand.CommandString);
-    }
-    [Fact]
+        Assert.Equal("Get-ADUser -Identity Test | Export-CSV ..\\..\\..\\SavedOutput\\output.csv",
+            returnedCommand.CommandString);
+    }*/
+
+    /*[Fact]
     public void ExecuteOutputToCSV()
     {
         PSSaveOptions pssave = new PSSaveOptions();
@@ -25,12 +29,8 @@ public void ExecuteOutputToCSV()
         InternalCommand test_command = new("get-process");
         ReturnValues temprv = executor.Execute(pssave.OutputToCSV(test_command));
 
-        //Check if a csv was made 
+        //Check if a csv was made
         Assert.True(File.Exists("..\\..\\..\\SavedOutput\\output.csv"));
         //File.Delete("..\\..\\..\\FAFB-PowerShell-Tool\\SavedOutput\\output.csv");
-    }
-
-
-
-
-}
\ No newline at end of file
+    }*/
+}
diff --git a/FAFB-PowerShell-Tool/MainWindow.xaml b/FAFB-PowerShell-Tool/MainWindow.xaml
index 579235b..35d0156 100644
--- a/FAFB-PowerShell-Tool/MainWindow.xaml
+++ b/FAFB-PowerShell-Tool/MainWindow.xaml
@@ -6,6 +6,10 @@
         xmlns:local="clr-namespace:FAFB_PowerShell_Tool"
         mc:Ignorable="d"
         Title="MainWindow" Height="500" Width="800">
+    <Window.DataContext>
+        <local:MainWindowViewModel />
+    </Window.DataContext>
+    
     <Grid>
         <!-- Define Rows -->
         <Grid.RowDefinitions>
@@ -44,9 +48,14 @@
                 </Grid.Background>
 
                 <!-- Stacked Queries are placed here. -->
-                <StackPanel x:Name="ButtonStackPanel" >
-
-                </StackPanel>
+                <StackPanel x:Name="ButtonStackPanel"></StackPanel>
+                <!--<ItemsControl ItemsSource="{Binding SavedQueries}">
+                    <ItemsControl.ItemTemplate>
+                        <DataTemplate>
+                            <Button Content="{Binding}" Height="48" />
+                        </DataTemplate>
+                    </ItemsControl.ItemTemplate>
+                </ItemsControl>-->
             </Grid>
 
             <!-- Grid Splitter for resizing -->
@@ -58,9 +67,7 @@
                     <TabControl>
                         <!-- Tab Items -->
                         <TabItem Header="Query Information">
-                            <!--<Grid Background="White">
-                                <Button x:Name="ExecutionButton" Content="Execute" Click="MExecutionButton" HorizontalAlignment="Left" Margin="206,88,0,0" VerticalAlignment="Top" Height="49" Width="140"  Grid.Column="2"/>
-                            </Grid>-->
+                            <Grid Background="White"></Grid>
                         </TabItem>
                         <!-- Tab Items -->
                         <TabItem Header="Query Builder">
@@ -75,16 +82,22 @@
                                 </Grid.RowDefinitions>
 
                                 <Grid Grid.Row="0">
-                                    <!-- Existing Controls -->
-                                    <ComboBox x:Name="ComboBoxCommandList" SelectionChanged="MComboBoxSelectionChanged" HorizontalAlignment="Left" Margin="26,48,0,0" VerticalAlignment="Top" Width="216" BorderBrush="#FFD41818" Background="Black" IsEditable="True" Grid.Row="0"/>
-                                    <ComboBox x:Name="ComboBoxCommandParameterList" HorizontalAlignment="Left" Margin="283,48,0,0" VerticalAlignment="Top" Width="212" IsEditable="True">
-                                        <ComboBox.Background>
-                                            <LinearGradientBrush EndPoint="0,1">
-                                                <GradientStop Color="#FFF0F0F0"/>
-                                                <GradientStop Color="White" Offset="1"/>
-                                            </LinearGradientBrush>
-                                        </ComboBox.Background>
-                                    </ComboBox>
+                                    <ComboBox x:Name="ComboBoxCommandList" 
+                                              ItemsSource="{Binding ActiveDirectoryCommandList}" 
+                                              SelectedItem="{Binding SelectedCommand}"
+                                              DisplayMemberPath="CommandText" 
+                                              HorizontalAlignment="Left" 
+                                              Margin="26,48,0,0" 
+                                              VerticalAlignment="Top" 
+                                              Width="216"  
+                                              IsEditable="True"/>
+                                    <ComboBox x:Name="ComboBoxCommandParameterList" 
+                                              ItemsSource="{Binding PossibleParameterList}" 
+                                              HorizontalAlignment="Left" 
+                                              Margin="283,48,0,0" 
+                                              VerticalAlignment="Top" 
+                                              Width="212" 
+                                              IsEditable="True" />
                                     <!-- This will be used for picking how you would like to output the query **not implemented yet** -->
                                     <ComboBox x:Name="ComboBoxOutputOptions" HorizontalAlignment="Left" Margin="26,100,0,0" VerticalAlignment="Top" Width="216" IsEditable="True">
                                         <ComboBox.Background>
@@ -97,7 +110,21 @@
                                 </Grid>
 
                                 <Grid Grid.Row="1" Margin="12,16">
-                                    <Button x:Name="SaveQueryButton" Click="MSaveQueryButton" Content="Save Query" HorizontalAlignment="Right" VerticalAlignment="Top" Height="29" Width="83"/>
+                                    <Grid.ColumnDefinitions>
+                                        <!-- Define two columns with equal width -->
+                                        <ColumnDefinition Width="*" />
+                                        <ColumnDefinition Width="*" />
+                                    </Grid.ColumnDefinitions>
+                                    
+                                    <!-- TODO: Joseph - Update to ensure binding and everything works correctly. -->
+                                    <Button x:Name="SaveQueryButton"
+                                            Content="Save Query"
+                                            Command="{Binding SavedQueries}"
+                                            CommandParameter="{Binding SelectedItem.Content, ElementName=ComboBoxCommandList}"
+                                            Grid.Column="0" />
+                                    <Button Content="Execute"
+                                            Command="{Binding ExecuteCommand}"
+                                            Grid.Column="1" />
                                 </Grid>
 
                                 <!-- GridSplitter for resizing console area in the second row -->
@@ -106,17 +133,9 @@
                                 <!-- TODO: Figure out why I can't get the console to be resizable to the min height... -->
                                 <Grid Grid.Row="3">
                                     <!-- TextBox as Console Output -->
-                                    <TextBox x:Name="ConsoleOutputTextBox" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Margin="10" IsReadOnly="True" TextWrapping="Wrap" VerticalScrollBarVisibility="Auto"/>
+                                    <TextBox Text="{Binding PowerShellOutput}" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Margin="10" IsReadOnly="True" TextWrapping="Wrap" VerticalScrollBarVisibility="Auto"/>
                                 </Grid>
                             </Grid>
-
-                        </TabItem>
-                        <!-- Tab Items -->
-                        <TabItem Header="Script Editor" HorizontalAlignment="Center" >
-                            <Grid Background="#FFE5E5E5" Height="406">
-                                <TextBox x:Name="ScriptEditorTextBox" HorizontalAlignment="Center" TextWrapping="Wrap" VerticalAlignment="Top" Width="568" Height="295" KeyboardNavigation.AcceptsReturn="True" Margin="0,10,0,0" Text=""/>
-                                <Button Content="Execute" HorizontalAlignment="Left" Margin="508,345,0,0" VerticalAlignment="Top" Height="25" Width="70"/>
-                            </Grid>
                         </TabItem>
                     </TabControl>
                 </Border>
diff --git a/FAFB-PowerShell-Tool/MainWindow.xaml.cs b/FAFB-PowerShell-Tool/MainWindow.xaml.cs
index d6d1596..187698d 100644
--- a/FAFB-PowerShell-Tool/MainWindow.xaml.cs
+++ b/FAFB-PowerShell-Tool/MainWindow.xaml.cs
@@ -1,131 +1,9 @@
-using System.Collections.ObjectModel;
-using System.Diagnostics;
-using System.Windows;
-using System.Windows.Controls;
-using FAFB_PowerShell_Tool.PowerShell;
-using FAFB_PowerShell_Tool.PowerShell.Commands;
-
 namespace FAFB_PowerShell_Tool;
 
 public partial class MainWindow
 {
-    // Creates an instance to be able to serialize the queries
-    CustomQueries CQ = new CustomQueries();
-
     public MainWindow()
     {
         InitializeComponent();
-        Loaded += MainWindow_Loaded; // Allows for async method to be called in the Loaded event.
-    }
-
-    /// <summary>
-    /// This method is used to populate the first ComboBox with the commands that are available.
-    /// </summary>
-    /// <param name="sender"></param>
-    /// <param name="e"></param>
-    private async void MainWindow_Loaded(object sender, RoutedEventArgs e)
-    {
-        ComboBox comboBoxCommandList = ComboBoxCommandList;
-        ObservableCollection<GuiCommand> list = await ActiveDirectoryCommands.GetActiveDirectoryCommands();
-        comboBoxCommandList.ItemsSource = list;
-        comboBoxCommandList.DisplayMemberPath = "CommandName";
-
-        FillCustomQueries();
-    }
-
-    /// <summary>
-    /// This method is used to populate the second ComboBox with the parameters of the selected command.
-    /// </summary>
-    /// <param name="sender"></param>
-    /// <param name="e"></param>
-    private async void MComboBoxSelectionChanged(object sender, SelectionChangedEventArgs e)
-    {
-        ComboBox comboBox = sender as ComboBox ?? throw new InvalidOperationException();
-
-        if (comboBox.SelectedItem is not GuiCommand selectedCommand)
-        {
-            return;
-        }
-
-        // Set the ItemsSource for the parameters ComboBox.
-        ComboBox comboBoxParameters = ComboBoxCommandParameterList;
-        await selectedCommand.LoadCommandParametersAsync(); // Lazy loading.
-        comboBoxParameters.ItemsSource = selectedCommand.PossibleParameters;
-    }
-
-    // TODO: Test to see if this works as it should...
-    // TODO: Make the buttons able to save a command to them and have a universal class maybe for executing them
-    private void MSaveQueryButton(object sender, RoutedEventArgs e)
-    {
-        // Try to get the content within the drop downs
-        try
-        {
-            // Get the Command
-            GuiCommand? command = ComboBoxCommandList.SelectedValue as GuiCommand;
-            // string commandParameters = cmbParameters.Text;
-
-            Button newButton = new() {
-
-                Content = "Special Command",
-                Height = 48
-            };
-            // Adds the query to the Queries serializable list
-            CQ.Queries.Add(command.CommandName);
-            // Adds the button in the stack panel
-            ButtonStackPanel.Children.Add(newButton);
-            // Saves the Queries to the file
-            CQ.SerializeMethod();
-        }
-        catch (Exception ex)
-        {
-            Console.Write(ex);
-        }
-    }
-    /// <summary>
-    /// This Method is to fill the left had side query bar
-    /// </summary>
-    private void FillCustomQueries()
-    {
-        try
-        {
-            CQ.LoadData();
-
-            foreach (string cQuery in CQ.Queries)
-            {
-                Button newButton = new() { Content = "Special Command", Height = 48 };
-
-                ButtonStackPanel.Children.Add(newButton);
-            }
-        }
-        catch (Exception ex)
-        {
-            Trace.WriteLine(ex);
-        }
     }
-
-    // TODO: Test to see if this works as it should...
-    /*private void ExecuteScriptEditorButton(object sender, RoutedEventArgs e)
-    {
-        string scriptEditorText = ScriptEditorTextBox.Text;
-        PowerShellExecutor powerShellExecutor = new();
-
-        Trace.WriteLine(scriptEditorText);
-
-        try
-        {
-            ReturnValues commandOutput = powerShellExecutor.Execute(scriptEditorText);
-            StringBuilder fullCommandOutput = new StringBuilder();
-
-            foreach (var str in commandOutput.StdOut)
-            {
-                fullCommandOutput.Append(str);
-            }
-
-            MessageBoxOutput.Show(fullCommandOutput.ToString());
-        }
-        catch (Exception ex)
-        {
-            MessageBoxOutput.Show(ex.Message, MessageBoxOutput.OutputType.InternalError);
-        }
-    }*/
 }
diff --git a/FAFB-PowerShell-Tool/MainWindowViewModel.cs b/FAFB-PowerShell-Tool/MainWindowViewModel.cs
new file mode 100644
index 0000000..869ffc0
--- /dev/null
+++ b/FAFB-PowerShell-Tool/MainWindowViewModel.cs
@@ -0,0 +1,131 @@
+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;
+
+namespace FAFB_PowerShell_Tool;
+
+public class MainWindowViewModel : INotifyPropertyChanged
+{
+    public ObservableCollection<Command> ActiveDirectoryCommandList { get; private set; }
+    public ObservableCollection<string> PossibleParameterList { get; private set; }
+    public ICommand ExecuteCommand { get; }
+
+    private readonly PowerShellExecutor _powerShellExecutor;
+
+    private Command _selectedCommand;
+    public Command SelectedCommand
+    {
+        get => _selectedCommand;
+        set {
+            _selectedCommand = value;
+            OnPropertyChanged(nameof(SelectedCommand));
+            LoadParametersAsync(value);
+        }
+    }
+
+    private string _powerShellOutput;
+    public string PowerShellOutput
+    {
+        get => _powerShellOutput;
+        set {
+            _powerShellOutput = value;
+            OnPropertyChanged(nameof(PowerShellOutput));
+        }
+    }
+
+    public MainWindowViewModel()
+    {
+        _powerShellExecutor = new PowerShellExecutor();
+        ExecuteCommand = new RelayCommand(Execute);
+        InitializeCommandsAsync();
+        LoadCustomQueries();
+    }
+
+    private async void Execute(object _)
+    {
+        await ExecuteSelectedCommand();
+    }
+
+    /// <summary>
+    /// Loads the Active Directory commands into the ActiveDirectoryCommandList property.
+    /// </summary>
+    private async void InitializeCommandsAsync()
+    {
+        ObservableCollection<Command> list = await ActiveDirectoryCommands.GetActiveDirectoryCommands();
+        ActiveDirectoryCommandList = new(list);
+        OnPropertyChanged(nameof(ActiveDirectoryCommandList));
+    }
+
+    /// <summary>
+    /// Loads the parameters for the selected command into the PossibleParameterList property.
+    /// </summary>
+    /// <param name="selectedCommand"></param>
+    private async void LoadParametersAsync(Command selectedCommand)
+    {
+        if (selectedCommand is not null)
+        {
+            CommandParameters commandParameters = new CommandParameters();
+            await commandParameters.LoadCommandParametersAsync(selectedCommand);
+            PossibleParameterList = new ObservableCollection<string>(commandParameters.PossibleParameters);
+            OnPropertyChanged(nameof(PossibleParameterList));
+        }
+    }
+
+    private async Task ExecuteSelectedCommand()
+    {
+        try
+        {
+            // Execute the command and get the results
+            ReturnValues result = await _powerShellExecutor.ExecuteAsync(SelectedCommand);
+
+            if (result.HadErrors)
+            {
+                // Handle errors here
+                // For example, display an error message in the UI
+                PowerShellOutput = string.Join(Environment.NewLine, result.StdErr);
+                return;
+            }
+
+            // Process the results here
+            // For example, you might want to display them in the UI
+            // Update a property that is bound to the UI
+            PowerShellOutput = string.Join(Environment.NewLine, result.StdOut);
+        }
+        catch (Exception ex)
+        {
+            // Handle any exceptions that occurred during execution
+            // For example, display an error message in the UI
+            PowerShellOutput = $"Error executing command: {ex.Message}";
+        }
+    }
+
+    public void SaveQueryCommand(string query)
+    {
+        // TODO: Write logic to save queries...
+    }
+
+    private void LoadCustomQueries()
+    {
+        // TODO: Write logic to load queries...
+    }
+
+    // ....BELOW CODE.... //
+
+    /// <summary>
+    /// This is the event handler for the INotifyPropertyChanged interface.
+    /// </summary>
+    public event PropertyChangedEventHandler? PropertyChanged;
+
+    /// <summary>
+    /// This is the method that is called when a property is changed.
+    /// </summary>
+    /// <param name="propertyName"></param>
+    protected virtual void OnPropertyChanged(string propertyName)
+    {
+        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+    }
+}
diff --git a/FAFB-PowerShell-Tool/PSSaveOptions.cs b/FAFB-PowerShell-Tool/PSSaveOptions.cs
index 90f5cd7..3ec1b60 100644
--- a/FAFB-PowerShell-Tool/PSSaveOptions.cs
+++ b/FAFB-PowerShell-Tool/PSSaveOptions.cs
@@ -1,65 +1,56 @@
 using FAFB_PowerShell_Tool.PowerShell;
-using FAFB_PowerShell_Tool.PowerShell.Commands;
 using System;
+using System.Management.Automation.Internal;
+using System.Management.Automation.Runspaces;
 
-namespace FAFB_PowerShell_Tool
+namespace FAFB_PowerShell_Tool;
+
+/// <summary>
+/// This class *might* be used for housing the save options
+/// </summary>
+public class PSSaveOptions
 {
     /// <summary>
-    /// This class *might* be used for housing the save options 
+    /// This would be to output the query to a csv, will need to eventually adapt to a guicommand as well most likely
     /// </summary>
-    public class PSSaveOptions
+    /// <param name="commandString"> This is the internal command that we want to output to a csv </param>
+    /*public Command OutputToCSV(Command commandString)
     {
-        /// <summary>
-        /// Empty Contructor
-        /// </summary>
-        public 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 InternalCommand OutputToCSV(InternalCommand commandString)
-        {
-            //Checks to see if the parameters are null, 
-            if (commandString.Parameters == null || commandString.Parameters.Length == 0)
-            {
-                //if they are null then make a new array with the output option, currently to relative path to SavedOutput folder
-                commandString.Parameters = new[] { "| 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)
+        //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");
         }
-        /// <summary>
-        /// This is used for saving the file to a PS1 powershell file
-        /// </summary>
-        public void SaveToPS(ReturnValues results)
+        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/Commands/ActiveDirectoryCommands.cs b/FAFB-PowerShell-Tool/PowerShell/ActiveDirectoryCommands.cs
similarity index 57%
rename from FAFB-PowerShell-Tool/PowerShell/Commands/ActiveDirectoryCommands.cs
rename to FAFB-PowerShell-Tool/PowerShell/ActiveDirectoryCommands.cs
index 27cec96..d79d438 100644
--- a/FAFB-PowerShell-Tool/PowerShell/Commands/ActiveDirectoryCommands.cs
+++ b/FAFB-PowerShell-Tool/PowerShell/ActiveDirectoryCommands.cs
@@ -1,10 +1,12 @@
 using System.Collections.ObjectModel;
 using System.Management.Automation;
+using System.Management.Automation.Runspaces;
+using System.Reflection.Metadata;
 
-namespace FAFB_PowerShell_Tool.PowerShell.Commands;
+namespace FAFB_PowerShell_Tool.PowerShell;
 
 /// <summary>
-/// Commands from the ActiveDirectory PowerShell module.
+/// ActiveDirectoryCommandList from the ActiveDirectory PowerShell module.
 /// </summary>
 public static class ActiveDirectoryCommands
 {
@@ -12,23 +14,24 @@ public static class ActiveDirectoryCommands
     /// This method will return a list of commands in the ActiveDirectory PowerShell module.
     /// </summary>
     /// <returns>Returns a list of commands in the ActiveDirectory PowerShell module.</returns>
-    /// <exception cref="InvalidPowerShellStateException">Thrown when an error has occurred when executing PowerShell commands.</exception>
-    public static async Task<ObservableCollection<GuiCommand>> GetActiveDirectoryCommands()
+    /// <exception cref="InvalidPowerShellStateException">Thrown when an error has occurred when executing PowerShell
+    /// commands.</exception>
+    public static async Task<ObservableCollection<Command>> GetActiveDirectoryCommands()
     {
         PowerShellExecutor powerShellExecutor = new();
-        ObservableCollection<GuiCommand> commandList = new();
-        InternalCommand commandString = new("Get-Command", new[] { "-Module", "ActiveDirectory" });
+        ObservableCollection<Command> commandList = new();
+        string commandString = "Get-Command -Module ActiveDirectory";
         ReturnValues commandListTemp = await powerShellExecutor.ExecuteAsync(commandString);
 
         if (commandListTemp.HadErrors)
         {
             MessageBoxOutput.Show(string.Join(" ", commandListTemp.StdErr), MessageBoxOutput.OutputType.Error);
-            throw new InvalidPowerShellStateException();  // TODO: Make exception output more info...
+            throw new InvalidPowerShellStateException(); // TODO: Make exception output more info...
         }
 
         foreach (var command in commandListTemp.StdOut)
         {
-            commandList.Add(new GuiCommand(command));
+            commandList.Add(new Command(command));
         }
 
         return commandList;
diff --git a/FAFB-PowerShell-Tool/PowerShell/CommandParameters.cs b/FAFB-PowerShell-Tool/PowerShell/CommandParameters.cs
new file mode 100644
index 0000000..a46b0ee
--- /dev/null
+++ b/FAFB-PowerShell-Tool/PowerShell/CommandParameters.cs
@@ -0,0 +1,42 @@
+using System.Collections.ObjectModel;
+using System.Management.Automation.Runspaces;
+
+namespace FAFB_PowerShell_Tool.PowerShell;
+
+public class CommandParameters
+{
+    private readonly ObservableCollection<string> _possibleParameters = new();
+    public ObservableCollection<string> PossibleParameters
+    {
+        get {
+            if (_possibleParameters.Count != 0)
+            {
+                return _possibleParameters;
+            }
+
+            throw new InvalidOperationException(
+                "PossibleParameters has not been populated via 'LoadCommandParametersAsync'.");
+        }
+    }
+
+    /// <summary>
+    /// Loads the possible parameters for the selected command into the '_possibleParameters' collection.
+    /// </summary>
+    /// <returns>A collection of parameter names for 'CommandName'</returns>
+    public async Task LoadCommandParametersAsync(Command commandObject)
+    {
+        string commandString =
+            $"Get-Command {commandObject.CommandText} | Select -ExpandProperty Parameters | ForEach-Object {{ $_.Keys }}";
+
+        if (_possibleParameters.Count == 0)
+        {
+            PowerShellExecutor powerShellExecutor = new();
+            ReturnValues tmpList = await powerShellExecutor.ExecuteAsync(commandString);
+
+            foreach (var command in tmpList.StdOut)
+            {
+                _possibleParameters.Add($"-{command}");
+            }
+        }
+    }
+}
diff --git a/FAFB-PowerShell-Tool/PowerShell/Commands/GuiCommand.cs b/FAFB-PowerShell-Tool/PowerShell/Commands/GuiCommand.cs
deleted file mode 100644
index 54e410c..0000000
--- a/FAFB-PowerShell-Tool/PowerShell/Commands/GuiCommand.cs
+++ /dev/null
@@ -1,55 +0,0 @@
-using System.Collections.ObjectModel;
-
-namespace FAFB_PowerShell_Tool.PowerShell.Commands;
-
-/// <summary>
-/// Commands that are intended to be selected and used via the GUI.
-/// </summary>
-/// <remarks>
-/// In addition to the base class, this class also contains a collection of possible parameters for the selected
-/// command.
-/// </remarks>
-/// <param name="commandName">The selected command.</param>
-/// <param name="parameters">Selected parameters for 'commandName'.</param>
-public class GuiCommand : InternalCommand
-{
-    private readonly ObservableCollection<string> _possibleParameters = new();
-    // NOTE: Calling 'LoadCommandParametersAsync' from this property's getter will cause the application to hang. This
-    //       is why the property throws an exception if the collection is empty, and requires the user to call the
-    //       'LoadCommandParametersAsync' method before accessing the collection.
-    public ObservableCollection<string> PossibleParameters
-    {
-        get {
-            if (_possibleParameters.Count != 0)
-            {
-                return _possibleParameters;
-            }
-
-            throw new InvalidOperationException(
-                "PossibleParameters has not been populated via 'LoadCommandParametersAsync'.");
-        }
-    }
-    
-    public GuiCommand(string commandName, string[]? parameters = null) : base(commandName, parameters)
-    { }
-
-    /// <summary>
-    /// Loads the possible parameters for the selected command into the '_possibleParameters' collection.
-    /// </summary>
-    /// <returns>A collection of parameter names for 'CommandName'</returns>
-    public async Task LoadCommandParametersAsync()
-    {
-        GuiCommand guiCommandString = new("Get-Command", new[] { CommandName, "| Select -ExpandProperty Parameters | ForEach-Object { $_.Keys }" });
-
-        if (_possibleParameters.Count == 0)
-        {
-            PowerShellExecutor powerShellExecutor = new();
-            ReturnValues tmpList = await powerShellExecutor.ExecuteAsync(guiCommandString);
-
-            foreach (var command in tmpList.StdOut)
-            {
-                _possibleParameters.Add($"-{command}");
-            }
-        }
-    }
-}
diff --git a/FAFB-PowerShell-Tool/PowerShell/Commands/ICommand.cs b/FAFB-PowerShell-Tool/PowerShell/Commands/ICommand.cs
deleted file mode 100644
index 0ad0e57..0000000
--- a/FAFB-PowerShell-Tool/PowerShell/Commands/ICommand.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-namespace FAFB_PowerShell_Tool.PowerShell.Commands;
-
-/// <summary>
-/// Interface for commands.
-/// </summary>
-/// <remarks>
-/// This interface is used to ensure that when executing a PowerShell command via 'PowerShellExecutor', the command type
-/// passed to the method has to be of type 'ICommand'.
-/// </remarks>
-public interface ICommand
-{
-    string CommandName { get; }
-    string[]? Parameters { get; set; }
-    string CommandString { get; }
-}
\ No newline at end of file
diff --git a/FAFB-PowerShell-Tool/PowerShell/Commands/InternalCommand.cs b/FAFB-PowerShell-Tool/PowerShell/Commands/InternalCommand.cs
deleted file mode 100644
index f00272c..0000000
--- a/FAFB-PowerShell-Tool/PowerShell/Commands/InternalCommand.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-namespace FAFB_PowerShell_Tool.PowerShell.Commands;
-
-/// <summary>
-/// Commands that are not intended to be used by the user/GUI, but rather by the program itself.
-/// </summary>
-/// <remarks>
-/// The separation of commands into 'InternalCommand' and 'GuiCommand' is because the internal commands don't need to
-/// know the possible parameters for the command, whereas the GUI commands do.
-/// </remarks>
-public class InternalCommand : ICommand
-{
-    public string CommandName { get; }
-    public string[]? Parameters { get; set; }
-    public string CommandString => Parameters is null ? CommandName : $"{CommandName} {string.Join(" ", Parameters)}";
-
-    /// <summary>
-    /// Commands that are not intended to be used by the user, but rather by the program itself.
-    /// </summary>
-    /// <param name="commandName">The selected command.</param>
-    /// <param name="parameters">Selected parameters for 'commandName'.</param>
-    /// <exception cref="ArgumentException">Thrown when 'commandName' is null, contains whitespace, or is blank</exception>
-    public InternalCommand(string commandName, string[]? parameters = null)
-    {
-        if (string.IsNullOrWhiteSpace(commandName))
-        {
-            //MessageBoxOutput.Show("Command name cannot be null or whitespace.", MessageBoxOutput.OutputType.Error);
-            throw new ArgumentException("Command name cannot be null or whitespace.", nameof(commandName));
-        }
-
-        CommandName = commandName;
-        Parameters = parameters;
-    }
-}
\ No newline at end of file
diff --git a/FAFB-PowerShell-Tool/PowerShell/PowerShellExecutor.cs b/FAFB-PowerShell-Tool/PowerShell/PowerShellExecutor.cs
index 01b2254..d450e96 100644
--- a/FAFB-PowerShell-Tool/PowerShell/PowerShellExecutor.cs
+++ b/FAFB-PowerShell-Tool/PowerShell/PowerShellExecutor.cs
@@ -1,6 +1,7 @@
-using System.IO;
+using System.Collections.ObjectModel;
 using System.Management.Automation;
-using FAFB_PowerShell_Tool.PowerShell.Commands;
+using System.Management.Automation.Runspaces;
+using System.Text;
 
 namespace FAFB_PowerShell_Tool.PowerShell;
 
@@ -20,46 +21,53 @@ public PowerShellExecutor()
         _powerShell.Commands.Clear();
     }
 
-    /// <summary>
-    /// Executes a PowerShell command synchronously.
-    /// </summary>
-    /// <typeparam name="T">Of type 'ICommand'.</typeparam>
-    /// <param name="commandString">The command and parameters in a single string.</param>
-    /// <returns>The processed and formatted results of the executed PowerShell command.</returns>
-    public ReturnValues Execute<T>(T commandString) where T : ICommand
+    public ReturnValues Execute(Command commandString)
+    {
+        return ExecuteInternal(CommandToString(commandString));
+    }
+
+    public ReturnValues Execute(string commandString)
+    {
+        return ExecuteInternal(commandString);
+    }
+
+    public async Task<ReturnValues> ExecuteAsync(Command commandString)
+    {
+        return await ExecuteInternalAsync(CommandToString(commandString));
+    }
+
+    public async Task<ReturnValues> ExecuteAsync(string commandString)
+    {
+        return await ExecuteInternalAsync(commandString);
+    }
+
+    private ReturnValues ExecuteInternal(string command)
     {
-        ValidateCommandString(commandString);
-        _powerShell.AddScript(commandString.CommandString);
-        var results = _powerShell.Invoke();
+        ValidateCommandString(command);
+        _powerShell.AddScript(command);
+        Collection<PSObject> results = _powerShell.Invoke();
         return ProcessPowerShellResults(results);
     }
 
-    /// <summary>
-    /// Executes a PowerShell command asynchronously.
-    /// </summary>
-    /// <typeparam name="T">Of type 'ICommand'.</typeparam>
-    /// <param name="commandString">The command and parameters in a single string.</param>
-    /// <returns>The processed and formatted results of the executed PowerShell command.</returns>
-    public async Task<ReturnValues> ExecuteAsync<T>(T commandString) where T : ICommand
+    private async Task<ReturnValues> ExecuteInternalAsync(string command)
     {
-        ValidateCommandString(commandString);
-        _powerShell.AddScript(commandString.CommandString);
-        var results = await _powerShell.InvokeAsync();
+        ValidateCommandString(command);
+        _powerShell.AddScript(command);
+        PSDataCollection<PSObject> results = await _powerShell.InvokeAsync();
         return await ProcessPowerShellResultsAsync(results);
     }
 
     /// <summary>
     /// Checks if the command string is null, contains whitespace, or is blank.
     /// </summary>
-    /// <typeparam name="T">Of type 'ICommand'.</typeparam>
     /// <param name="commandString">The command and parameters in a single string.</param>
-    /// <exception cref="ArgumentException">Thrown when 'commandName' is null, contains whitespace, or is blank</exception>
-    private void ValidateCommandString<T>(T commandString) where T : ICommand
+    /// <exception cref="ArgumentException">Thrown when 'commandName' is null, contains whitespace, or is
+    /// blank</exception>
+    private void ValidateCommandString(string commandString)
     {
-        if (string.IsNullOrWhiteSpace(commandString.CommandString))
+        if (string.IsNullOrWhiteSpace(commandString))
         {
-            MessageBoxOutput.Show("Command text cannot be null or whitespace.", MessageBoxOutput.OutputType.Error);
-            throw new ArgumentException("Command text cannot be null or whitespace.", nameof(commandString));
+            throw new ArgumentException("Command string cannot be null, contain whitespace, or be blank.");
         }
     }
 
@@ -99,5 +107,21 @@ private Task<ReturnValues> ProcessPowerShellResultsAsync(IEnumerable<PSObject> r
     {
         return Task.FromResult(ProcessPowerShellResults(results));
     }
+
+    public string CommandToString(Command command)
+    {
+        StringBuilder commandString = new StringBuilder();
+
+        // Add the command name
+        commandString.Append(command.CommandText);
+
+        // Iterate over the parameters and add them to the string
+        foreach (var param in command.Parameters)
+        {
+            commandString.Append($" -{param.Name} {param.Value}");
+        }
+
+        return commandString.ToString();
+    }
 }
 
diff --git a/FAFB-PowerShell-Tool/RelayCommand.cs b/FAFB-PowerShell-Tool/RelayCommand.cs
new file mode 100644
index 0000000..742370c
--- /dev/null
+++ b/FAFB-PowerShell-Tool/RelayCommand.cs
@@ -0,0 +1,38 @@
+using System.Windows.Input;
+
+namespace FAFB_PowerShell_Tool;
+
+public class RelayCommand : ICommand
+{
+    private readonly Action<object> _execute;
+    private readonly Predicate<object> _canExecute;
+
+    public RelayCommand(Action<object> execute, Predicate<object> canExecute = null)
+    {
+        _execute = execute ?? throw new ArgumentNullException(nameof(execute));
+        _canExecute = canExecute;
+    }
+
+    public bool CanExecute(object parameter)
+    {
+        return _canExecute?.Invoke(parameter) ?? true;
+    }
+
+    public void Execute(object parameter)
+    {
+        _execute(parameter);
+    }
+
+    public event EventHandler CanExecuteChanged
+    {
+        add
+        {
+            CommandManager.RequerySuggested += value;
+        }
+        remove
+        {
+            CommandManager.RequerySuggested -= value;
+        }
+    }
+}
+