diff --git a/Discord.Net.SlashCommands/Builders/SlashCommandBuilder.cs b/Discord.Net.SlashCommands/Builders/SlashCommandBuilder.cs
new file mode 100644
index 000000000..75995525a
--- /dev/null
+++ b/Discord.Net.SlashCommands/Builders/SlashCommandBuilder.cs
@@ -0,0 +1,491 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+
+namespace Discord.SlashCommands.Builders
+{
+    /// <summary>
+    ///     A class used to build slash commands.
+    /// </summary>
+    public class SlashCommandBuilder
+    {
+        /// <summary> 
+        ///     Returns the maximun length a commands name allowed by Discord
+        /// </summary>
+        public const int MaxNameLength = 32;
+        /// <summary> 
+        ///     Returns the maximum length of a commands description allowed by Discord. 
+        /// </summary>
+        public const int MaxDescriptionLength = 100;
+        /// <summary> 
+        ///     Returns the maximum count of command options allowed by Discord
+        /// </summary>
+        public const int MaxOptionsCount = 10;
+
+        /// <summary>
+        ///     The name of this slash command.
+        /// </summary>
+        public string Name
+        {
+            get
+            {
+                return _name;
+            }
+            set
+            {
+                Preconditions.NotNullOrEmpty(value, nameof(Name));
+                Preconditions.AtLeast(value.Length, 3, nameof(Name));
+                Preconditions.AtMost(value.Length, MaxNameLength, nameof(Name));
+
+                // Discord updated the docs, this regex prevents special characters like @!$%(... etc,
+                // https://discord.com/developers/docs/interactions/slash-commands#applicationcommand
+                if (!Regex.IsMatch(value, @"^[\w-]{3,32}$"))
+                    throw new ArgumentException("Command name cannot contian any special characters or whitespaces!");
+
+                _name = value;
+            }
+        }
+
+        /// <summary>
+        ///    A 1-100 length description of this slash command
+        /// </summary>
+        public string Description
+        {
+            get
+            {
+                return _description;
+            }
+            set
+            {
+                Preconditions.AtLeast(value.Length, 1, nameof(Description));
+                Preconditions.AtMost(value.Length, MaxDescriptionLength, nameof(Description));
+
+                _description = value;
+            }
+        }
+
+        public ulong GuildId
+        {
+            get
+            {
+                return _guildId ?? 0;
+            }
+            set
+            {
+                if (value == 0)
+                {
+                    throw new ArgumentException("Guild ID cannot be 0!");
+                }
+
+                _guildId = value;
+
+                if (isGlobal)
+                    isGlobal = false;
+            }
+        }
+        /// <summary>
+        ///     Gets or sets the options for this command.
+        /// </summary>
+        public List<SlashCommandOptionBuilder> Options
+        {
+            get
+            {
+                return _options;
+            }
+            set
+            {
+                if (value != null)
+                    if (value.Count > MaxOptionsCount)
+                        throw new ArgumentException(message: $"Option count must be less than or equal to {MaxOptionsCount}.", paramName: nameof(Options));
+
+                _options = value;
+            }
+        }
+
+        private ulong? _guildId { get; set; }
+        private string _name { get; set; }
+        private string _description { get; set; }
+        private List<SlashCommandOptionBuilder> _options { get; set; }
+
+        internal bool isGlobal { get; set; }
+
+
+        public SlashCommandCreationProperties Build()
+        {
+            SlashCommandCreationProperties props = new SlashCommandCreationProperties()
+            {
+                Name = this.Name,
+                Description = this.Description,
+            };
+
+            if(this.Options != null || this.Options.Any())
+            {
+                var options = new List<ApplicationCommandOptionProperties>();
+
+                this.Options.ForEach(x => options.Add(x.Build()));
+
+                props.Options = options;
+            }
+
+            return props;
+
+        }
+
+        /// <summary>
+        ///     Makes this command a global application command .
+        /// </summary>
+        /// <returns>The current builder.</returns>
+        public SlashCommandBuilder MakeGlobal()
+        {
+            this.isGlobal = true;
+            return this;
+        }
+
+        /// <summary>
+        ///     Makes this command a guild specific command.
+        /// </summary>
+        /// <param name="GuildId">The Id of the target guild.</param>
+        /// <returns>The current builder.</returns>
+        public SlashCommandBuilder ForGuild(ulong GuildId)
+        {
+            this.GuildId = GuildId;
+            return this;
+        }
+
+        public SlashCommandBuilder WithName(string Name)
+        {
+            this.Name = Name;
+            return this;
+        }
+
+        /// <summary>
+        ///     Sets the description of the current command.
+        /// </summary>
+        /// <param name="Description">The description of this command.</param>
+        /// <returns>The current builder.</returns>
+        public SlashCommandBuilder WithDescription(string Description)
+        {
+            this.Description = Description;
+            return this;
+        }
+
+        /// <summary>
+        ///     Adds an option to the current slash command.
+        /// </summary>
+        /// <param name="Name">The name of the option to add.</param>
+        /// <param name="Type">The type of this option.</param>
+        /// <param name="Description">The description of this option.</param>
+        /// <param name="Required">If this option is required for this command.</param>
+        /// <param name="Default">If this option is the default option.</param>
+        /// <param name="Options">The options of the option to add.</param>
+        /// <param name="Choices">The choices of this option.</param>
+        /// <returns>The current builder.</returns>
+        public SlashCommandBuilder AddOption(string Name, ApplicationCommandOptionType Type,
+           string Description, bool Required = true, bool Default = false, List<SlashCommandOptionBuilder> Options = null, params ApplicationCommandOptionChoiceProperties[] Choices)
+        {
+            // Make sure the name matches the requirements from discord
+            Preconditions.NotNullOrEmpty(Name, nameof(Name));
+            Preconditions.AtLeast(Name.Length, 3, nameof(Name));
+            Preconditions.AtMost(Name.Length, MaxNameLength, nameof(Name));
+
+            // Discord updated the docs, this regex prevents special characters like @!$%( and s p a c e s.. etc,
+            // https://discord.com/developers/docs/interactions/slash-commands#applicationcommand
+            if (!Regex.IsMatch(Name, @"^[\w-]{3,32}$"))
+                throw new ArgumentException("Command name cannot contian any special characters or whitespaces!", nameof(Name));
+
+            // same with description
+            Preconditions.NotNullOrEmpty(Description, nameof(Description));
+            Preconditions.AtLeast(Description.Length, 3, nameof(Description));
+            Preconditions.AtMost(Description.Length, MaxDescriptionLength, nameof(Description));
+
+            // make sure theres only one option with default set to true
+            if (Default)
+            {
+                if (this.Options != null)
+                    if (this.Options.Any(x => x.Default))
+                        throw new ArgumentException("There can only be one command option with default set to true!", nameof(Default));
+            }
+
+            SlashCommandOptionBuilder option = new SlashCommandOptionBuilder();
+            option.Name = Name;
+            option.Description = Description;
+            option.Required = Required;
+            option.Default = Default;
+            option.Options = Options;
+            option.Choices = Choices != null ? new List<ApplicationCommandOptionChoiceProperties>(Choices) : null;
+
+            return AddOption(option);
+        }
+
+        /// <summary>
+        ///     Adds an option to the current slash command.
+        /// </summary>
+        /// <param name="Name">The name of the option to add.</param>
+        /// <param name="Type">The type of this option.</param>
+        /// <param name="Description">The description of this option.</param>
+        /// <param name="Required">If this option is required for this command.</param>
+        /// <param name="Default">If this option is the default option.</param>
+        /// <param name="Choices">The choices of this option.</param>
+        /// <returns>The current builder.</returns>
+        public SlashCommandBuilder AddOption(string Name, ApplicationCommandOptionType Type,
+            string Description, bool Required = true, bool Default = false, params ApplicationCommandOptionChoiceProperties[] Choices)
+            => AddOption(Name, Type, Description, Required, Default, null, Choices);
+
+        /// <summary>
+        ///     Adds an option to the current slash command.
+        /// </summary>
+        /// <param name="Name">The name of the option to add.</param>
+        /// <param name="Type">The type of this option.</param>
+        /// <param name="Description">The sescription of this option.</param>
+        /// <returns>The current builder.</returns>
+        public SlashCommandBuilder AddOption(string Name, ApplicationCommandOptionType Type, string Description)
+            => AddOption(Name, Type, Description, Options: null, Choices: null);
+
+        /// <summary>
+        ///     Adds an option to this slash command.
+        /// </summary>
+        /// <param name="Parameter">The option to add.</param>
+        /// <returns>The current builder.</returns>
+        public SlashCommandBuilder AddOption(SlashCommandOptionBuilder Option)
+        {
+            if (this.Options == null)
+                this.Options = new List<SlashCommandOptionBuilder>();
+
+            if (this.Options.Count >= MaxOptionsCount)
+                throw new ArgumentOutOfRangeException(nameof(Options), $"Cannot have more than {MaxOptionsCount} options!");
+
+            if (Option == null)
+                throw new ArgumentNullException(nameof(Option), "Option cannot be null");
+
+            this.Options.Add(Option);
+            return this;
+        }
+        /// <summary>
+        ///     Adds a collection of options to the current slash command.
+        /// </summary>
+        /// <param name="Parameter">The collection of options to add.</param>
+        /// <returns>The current builder.</returns>
+        public SlashCommandBuilder AddOptions(params SlashCommandOptionBuilder[] Options)
+        {
+            if (Options == null)
+                throw new ArgumentNullException(nameof(Options), "Options cannot be null!");
+
+            if (Options.Length == 0)
+                throw new ArgumentException(nameof(Options), "Options cannot be empty!");
+
+            if (this.Options == null)
+                this.Options = new List<SlashCommandOptionBuilder>();
+
+            if (this.Options.Count + Options.Length > MaxOptionsCount)
+                throw new ArgumentOutOfRangeException(nameof(Options), $"Cannot have more than {MaxOptionsCount} options!");
+
+            this.Options.AddRange(Options);
+            return this;
+        }
+    }
+
+    /// <summary>
+    ///     Represents a class used to build options for the <see cref="SlashCommandBuilder"/>.
+    /// </summary>
+    public class SlashCommandOptionBuilder
+    {
+        /// <summary>
+        ///     The max length of a choice's name allowed by Discord.
+        /// </summary>
+        public const int ChoiceNameMaxLength = 100;
+
+        /// <summary>
+        ///     The maximum number of choices allowed by Discord.
+        /// </summary>
+        public const int MaxChoiceCount = 10;
+
+        private string _name;
+        private string _description;
+
+        /// <summary>
+        ///     The name of this option.
+        /// </summary>
+        public string Name
+        {
+            get => _name;
+            set
+            {
+                if (value?.Length > SlashCommandBuilder.MaxNameLength)
+                    throw new ArgumentException("Name length must be less than or equal to 32");
+                if(value?.Length < 3)
+                    throw new ArgumentException("Name length must at least 3 characters in length");
+
+                // Discord updated the docs, this regex prevents special characters like @!$%(... etc,
+                // https://discord.com/developers/docs/interactions/slash-commands#applicationcommand
+                if (!Regex.IsMatch(value, @"^[\w-]{3,32}$"))
+                    throw new ArgumentException("Option name cannot contian any special characters or whitespaces!");
+
+                _name = value;
+            }
+        }
+
+        /// <summary>
+        ///     The description of this option.
+        /// </summary>
+        public string Description
+        {
+            get => _description;
+            set
+            {
+                if (value?.Length > SlashCommandBuilder.MaxDescriptionLength)
+                    throw new ArgumentException("Description length must be less than or equal to 100");
+                if (value?.Length < 1)
+                    throw new ArgumentException("Name length must at least 1 character in length");
+
+                _description = value;
+            }
+        }
+
+        /// <summary>
+        ///     The type of this option.
+        /// </summary>
+        public ApplicationCommandOptionType Type { get; set; }
+
+        /// <summary>
+        ///     The first required option for the user to complete. only one option can be default.
+        /// </summary>
+        public bool Default { get; set; }
+
+        /// <summary>
+        ///     <see langword="true"/> if this option is required for this command, otherwise <see langword="false"/>.
+        /// </summary>
+        public bool Required { get; set; }
+
+        /// <summary>
+        ///     choices for string and int types for the user to pick from.
+        /// </summary>
+        public List<ApplicationCommandOptionChoiceProperties> Choices { get; set; }
+
+        /// <summary>
+        ///     If the option is a subcommand or subcommand group type, this nested options will be the parameters.
+        /// </summary>
+        public List<SlashCommandOptionBuilder> Options { get; set; }
+
+        /// <summary>
+        ///     Builds the current option.
+        /// </summary>
+        /// <returns>The build version of this option</returns>
+        public ApplicationCommandOptionProperties Build()
+        {
+            bool isSubType = this.Type == ApplicationCommandOptionType.SubCommand || this.Type == ApplicationCommandOptionType.SubCommandGroup;
+
+            if (isSubType && (Options == null || !Options.Any()))
+                throw new ArgumentException(nameof(Options), "SubCommands/SubCommandGroups must have at least one option");
+
+            if (!isSubType && (Options != null && Options.Any()))
+                throw new ArgumentException(nameof(Options), $"Cannot have options on {Type} type");
+
+            return new ApplicationCommandOptionProperties()
+            {
+                Name = this.Name,
+                Description = this.Description,
+                Default = this.Default,
+                Required = this.Required,
+                Type = this.Type,
+                Options = new List<ApplicationCommandOptionProperties>(this.Options.Select(x => x.Build())),
+                Choices = this.Choices
+            };
+        }
+
+        /// <summary>
+        ///     Adds a sub 
+        /// </summary>
+        /// <param name="option"></param>
+        /// <returns></returns>
+        public SlashCommandOptionBuilder AddOption(SlashCommandOptionBuilder option)
+        {
+            if (this.Options == null)
+                this.Options = new List<SlashCommandOptionBuilder>();
+
+            if (this.Options.Count >= SlashCommandBuilder.MaxOptionsCount)
+                throw new ArgumentOutOfRangeException(nameof(Choices), $"There can only be {SlashCommandBuilder.MaxOptionsCount} options per sub command group!");
+
+            if (option == null)
+                throw new ArgumentNullException(nameof(option), "Option cannot be null");
+
+            Options.Add(option);
+            return this;
+        }
+
+        public SlashCommandOptionBuilder AddChoice(string Name, int Value)
+        {
+            if (Choices == null)
+                Choices = new List<ApplicationCommandOptionChoiceProperties>();
+
+            if (Choices.Count >= MaxChoiceCount)
+                throw new ArgumentOutOfRangeException(nameof(Choices), $"Cannot add more than {MaxChoiceCount} choices!");
+
+            Choices.Add(new ApplicationCommandOptionChoiceProperties()
+            {
+                Name = Name,
+                Value = Value
+            });
+
+            return this;
+        }
+        public SlashCommandOptionBuilder AddChoice(string Name, string Value)
+        {
+            if (Choices == null)
+                Choices = new List<ApplicationCommandOptionChoiceProperties>();
+
+            if (Choices.Count >= MaxChoiceCount)
+                throw new ArgumentOutOfRangeException(nameof(Choices), $"Cannot add more than {MaxChoiceCount} choices!");
+
+            Choices.Add(new ApplicationCommandOptionChoiceProperties()
+            {
+                Name = Name,
+                Value = Value
+            });
+
+            return this;
+        }
+
+        public SlashCommandOptionBuilder WithName(string Name, int Value)
+        {
+            if (Choices == null)
+                Choices = new List<ApplicationCommandOptionChoiceProperties>();
+
+            if (Choices.Count >= MaxChoiceCount)
+                throw new ArgumentOutOfRangeException(nameof(Choices), $"Cannot add more than {MaxChoiceCount} choices!");
+
+            Choices.Add(new ApplicationCommandOptionChoiceProperties()
+            {
+                Name = Name,
+                Value = Value
+            });
+
+            return this;
+        }
+
+        public SlashCommandOptionBuilder WithDescription(string Description)
+        {
+            this.Description = Description;
+            return this;
+        }
+
+        public SlashCommandOptionBuilder WithRequired(bool value)
+        {
+            this.Required = value;
+            return this;
+        }
+
+        public SlashCommandOptionBuilder WithDefault(bool value)
+        {
+            this.Default = value;
+            return this;
+        }
+        public SlashCommandOptionBuilder WithType(ApplicationCommandOptionType Type)
+        {
+            this.Type = Type;
+            return this;
+        }
+    }
+}
diff --git a/Discord.Net.SlashCommands/Discord.Net.SlashCommands.csproj b/Discord.Net.SlashCommands/Discord.Net.SlashCommands.csproj
new file mode 100644
index 000000000..70b29c74b
--- /dev/null
+++ b/Discord.Net.SlashCommands/Discord.Net.SlashCommands.csproj
@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  
+  <PropertyGroup>
+    <AssemblyName>Discord.Net.SlashCommands</AssemblyName>
+    <RootNamespace>Discord.SlashCommands</RootNamespace>
+    <Description>A Discord.Net extension adding support for slash commands.</Description>
+    <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">net461;netstandard2.0;netstandard2.1</TargetFrameworks>
+    <TargetFrameworks Condition=" '$(OS)' != 'Windows_NT' ">netstandard2.0;netstandard2.1</TargetFrameworks>
+  </PropertyGroup>
+  
+  <ItemGroup>
+    <ProjectReference Include="..\src\Discord.Net.Core\Discord.Net.Core.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/Discord.Net.sln b/Discord.Net.sln
index 1a32f1270..084d8a834 100644
--- a/Discord.Net.sln
+++ b/Discord.Net.sln
@@ -40,7 +40,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Discord.Net.Analyzers.Tests
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Discord.Net.Examples", "src\Discord.Net.Examples\Discord.Net.Examples.csproj", "{47820065-3CFB-401C-ACEA-862BD564A404}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "idn", "samples\idn\idn.csproj", "{4A03840B-9EBE-47E3-89AB-E0914DF21AFB}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "idn", "samples\idn\idn.csproj", "{4A03840B-9EBE-47E3-89AB-E0914DF21AFB}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
diff --git a/src/Discord.Net.Commands/Builders/SlashCommandBuilder.cs b/src/Discord.Net.Commands/Builders/SlashCommandBuilder.cs
index 523137858..6087825b4 100644
--- a/src/Discord.Net.Commands/Builders/SlashCommandBuilder.cs
+++ b/src/Discord.Net.Commands/Builders/SlashCommandBuilder.cs
@@ -390,7 +390,7 @@ namespace Discord.Commands.Builders
                 Default = this.Default,
                 Required = this.Required,
                 Type = this.Type,
-                Options = new List<ApplicationCommandOptionProperties>(this.Options.Select(x => x.Build())),
+                Options = Options != null ? new List<ApplicationCommandOptionProperties>(this.Options.Select(x => x.Build())) : null,
                 Choices = this.Choices
             };
         }
diff --git a/src/Discord.Net.Commands/SlashCommands/Attributes/SlashCommand.cs b/src/Discord.Net.Commands/SlashCommands/Attributes/SlashCommand.cs
new file mode 100644
index 000000000..8b60eabc1
--- /dev/null
+++ b/src/Discord.Net.Commands/SlashCommands/Attributes/SlashCommand.cs
@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Discord.SlashCommands
+{
+    /// <summary>
+    ///     Defines the current class or function as a slash command.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = false)]
+    public class SlashCommand : Attribute
+    {
+        /// <summary>
+        ///     The name of this slash command.
+        /// </summary>
+        public string CommandName;
+
+        /// <summary>
+        ///     Tells the <see cref="SlashCommandService"/> that this class/function is a slash command.
+        /// </summary>
+        /// <param name="CommandName">The name of this slash command.</param>
+        public SlashCommand(string CommandName)
+        {
+            this.CommandName = CommandName;
+        }
+    }
+}
diff --git a/src/Discord.Net.Commands/SlashCommands/SlashCommandService.cs b/src/Discord.Net.Commands/SlashCommands/SlashCommandService.cs
new file mode 100644
index 000000000..f075dd833
--- /dev/null
+++ b/src/Discord.Net.Commands/SlashCommands/SlashCommandService.cs
@@ -0,0 +1,30 @@
+using Discord.Commands;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Discord.SlashCommands
+{
+    public class SlashCommandService
+    {
+        private List<SlashCommandModule> _modules;
+
+        public SlashCommandService() // TODO: possible config?
+        {
+
+        }
+
+        public void AddAssembly()
+        {
+
+        }
+
+        public async Task<IResult> ExecuteAsync()
+        {
+            // TODO: handle execution
+            return null;
+        }
+    }
+}
diff --git a/src/Discord.Net.Commands/SlashCommands/Types/SlashCommandBase.cs b/src/Discord.Net.Commands/SlashCommands/Types/SlashCommandBase.cs
new file mode 100644
index 000000000..0fe947e6d
--- /dev/null
+++ b/src/Discord.Net.Commands/SlashCommands/Types/SlashCommandBase.cs
@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Discord.Commands.SlashCommands.Types
+{
+    /// <summary>
+    ///     The base class to inherit for your slash command class's.
+    /// </summary>
+    /// <typeparam name="T">The type of the interaction.</typeparam>
+    public abstract class SlashCommandBase<T> where T : IDiscordInteraction
+    {
+        public event Func<SlashCommandContext<T>, Task> CommandExecuted; 
+        public SlashCommandBase()
+        {
+
+        }
+
+        public void Register(SlashCommandCreationProperties command)
+        {
+            // TODO: register it, make sure that this command is what discord is expecting
+        }
+
+        internal Task ExecuteInternalAsync(IDiscordInteraction interaction)
+        {
+            // try catch? 
+            return this.CommandExecuted?.Invoke(new SlashCommandContext<T>(interaction));
+        }
+    }
+
+    /// <summary>
+    ///     The base class to inherit for your slash command class's.
+    /// </summary>
+    public abstract class SlashCommandBase : SlashCommandBase<IDiscordInteraction> { }
+}
diff --git a/src/Discord.Net.Commands/SlashCommands/Types/SlashCommandContext.cs b/src/Discord.Net.Commands/SlashCommands/Types/SlashCommandContext.cs
new file mode 100644
index 000000000..edb6b9f3f
--- /dev/null
+++ b/src/Discord.Net.Commands/SlashCommands/Types/SlashCommandContext.cs
@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Discord.Commands.SlashCommands.Types
+{
+    public class SlashCommandContext<T> where T : IDiscordInteraction
+    {
+        public T Interaction;
+
+        public IGuild Guild
+            => Interaction.Guild;
+
+        internal SlashCommandContext(IDiscordInteraction interaction)
+        {
+            this.Interaction = (T)interaction;
+        }
+    }
+}
diff --git a/src/Discord.Net.Commands/SlashCommands/Types/SlashCommandModule.cs b/src/Discord.Net.Commands/SlashCommands/Types/SlashCommandModule.cs
new file mode 100644
index 000000000..6e54e920a
--- /dev/null
+++ b/src/Discord.Net.Commands/SlashCommands/Types/SlashCommandModule.cs
@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Discord.SlashCommands
+{
+    internal class SlashCommandModule
+    {
+        
+    }
+}
diff --git a/src/Discord.Net.Core/Entities/Interactions/IDiscordInteraction.cs b/src/Discord.Net.Core/Entities/Interactions/IDiscordInteraction.cs
index 2cc0faf4f..037852eff 100644
--- a/src/Discord.Net.Core/Entities/Interactions/IDiscordInteraction.cs
+++ b/src/Discord.Net.Core/Entities/Interactions/IDiscordInteraction.cs
@@ -20,6 +20,11 @@ namespace Discord
         /// </summary>
         ulong Id { get; }
 
+        /// <summary>
+        /// 
+        /// </summary>
+        IGuild Guild { get; }
+
         /// <summary>
         ///     The type of this <see cref="IDiscordInteraction"/>.
         /// </summary>
diff --git a/src/Discord.Net.WebSocket/Entities/Interaction/SocketInteraction.cs b/src/Discord.Net.WebSocket/Entities/Interaction/SocketInteraction.cs
index 4a8277fd4..06a5d53c7 100644
--- a/src/Discord.Net.WebSocket/Entities/Interaction/SocketInteraction.cs
+++ b/src/Discord.Net.WebSocket/Entities/Interaction/SocketInteraction.cs
@@ -211,5 +211,6 @@ namespace Discord.WebSocket
         }
 
         IApplicationCommandInteractionData IDiscordInteraction.Data => Data;
+        IGuild IDiscordInteraction.Guild => Guild;
     }
 }
diff --git a/src/Discord.Net.WebSocket/Entities/Interaction/SocketInteractionDataOption.cs b/src/Discord.Net.WebSocket/Entities/Interaction/SocketInteractionDataOption.cs
index 62097689d..fea0bf3b6 100644
--- a/src/Discord.Net.WebSocket/Entities/Interaction/SocketInteractionDataOption.cs
+++ b/src/Discord.Net.WebSocket/Entities/Interaction/SocketInteractionDataOption.cs
@@ -38,6 +38,7 @@ namespace Discord.WebSocket
             this.Options = model.Options.IsSpecified
                 ? model.Options.Value.Select(x => new SocketInteractionDataOption(x, discord, guild)).ToImmutableArray()
                 : null;
+
         }
 
         // Converters